euler: use enum and static values for EULER ORDER, remove some macros

this must be more robust and flexible api

.gitattributes

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

.gitignore

@@ -72,7 +72,3 @@ cglm-test-ios*
 /cglm.pc
 test-driver
 Default-568h@2x.png
-build/
-conftest.dir/*
-confdefs.h
-*.xcuserdatad

.travis.yml

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

.vscode/settings.json

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

CMakeLists.txt

@@ -1,123 +0,0 @@
-cmake_minimum_required(VERSION 3.8.2)
-project(cglm VERSION 0.8.0 LANGUAGES C)
-
-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)
-option(CGLM_STATIC "Static build" OFF)
-option(CGLM_USE_C99 "" OFF)
-option(CGLM_USE_TEST "Enable Tests" OFF)
-
-if(NOT CGLM_STATIC AND CGLM_SHARED)
-  set(CGLM_BUILD SHARED)
-else(CGLM_STATIC)
-  set(CGLM_BUILD STATIC)
-endif()
-
-if(CGLM_USE_C99)
-  set(CMAKE_C_STANDARD 99)
-endif()
-
-if(MSVC)
-  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 -O3)
-endif()
-
-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()
-
-include(GNUInstallDirs)
-
-set(CPACK_PROJECT_NAME ${PROJECT_NAME})
-set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-include(CPack)
-
-# Target Start
-add_library(${PROJECT_NAME}
-  ${CGLM_BUILD}
-  src/euler.c
-  src/affine.c
-  src/io.c
-  src/quat.c
-  src/cam.c
-  src/vec2.c
-  src/vec3.c
-  src/vec4.c
-  src/mat2.c
-  src/mat3.c
-  src/mat4.c
-  src/plane.c
-  src/frustum.c
-  src/box.c
-  src/project.c
-  src/sphere.c
-  src/ease.c
-  src/curve.c
-  src/bezier.c
-  src/ray.c
-  src/affine2d.c
-  )
-
-if(CGLM_SHARED)
-  add_definitions(-DCGLM_EXPORTS)
-else()
-  target_compile_definitions(${PROJECT_NAME} PUBLIC -DCGLM_STATIC)
-endif()
-
-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})
-

CREDITS

@@ -65,12 +65,19 @@ https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolati
 12. vec2 cross product
 http://allenchou.net/2013/07/cross-product-of-2d-vectors/
 
-13. Ray triangle intersect
-Möller–Trumbore ray-triangle intersection algorithm, from "Fast, Minimum Storage Ray/Triangle Intersection"
-Authors:
-  Thomas Möller (tompa@clarus.se)
-  Ben Trumbore (wbt@graphics.cornell.edu)
-Link to paper: http://webserver2.tecgraf.puc-rio.br/~mgattass/cg/trbRR/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf
+13. Ken Shoemake's algorithm Implementation and Euler
+Ken Shoemake's algorithm impl. is taken from this repo by permission:
+  https://github.com/erich666/GraphicsGems/blob/master/gemsiv/euler_angle
 
-14. ARM NEON: Matrix Vector Multiplication
-https://stackoverflow.com/a/57793352/2676533
+* -------------------------- GraphicsGems EULA ----------------------------- *
+|   http://www.realtimerendering.com/resources/GraphicsGems/                 |
+|                                                                            |
+| EULA: The Graphics Gems code is copyright-protected. In other words, you   |
+| cannot claim the text of the code as your own and resell it. Using the     |
+| code is permitted in any program, product, or library, non-commercial or   |
+| commercial. Giving credit is not required, though is a nice gesture.       |
+| The code comes as-is, and if there are any flaws or problems with any Gems |
+| code, nobody involved with Gems - authors, editors, publishers, or         |
+| webmasters - are to be held responsible. Basically, don't be a jerk, and   |
+| remember that anything free comes with no guarantee.                       |
+* -------------------------------- END --------------------------------------*/

Makefile.am

@@ -12,6 +12,7 @@ AM_CFLAGS = -Wall \
             -O3 \
             -Wstrict-aliasing=2 \
             -fstrict-aliasing \
+            -pedantic \
             -Werror=strict-prototypes
 
 lib_LTLIBRARIES = libcglm.la
@@ -21,10 +22,7 @@ checkLDFLAGS = -L./.libs \
                -lm \
                -lcglm
 checkCFLAGS = $(AM_CFLAGS) \
-               -std=gnu11 \
-               -O3 \
-               -DCGLM_DEFINE_PRINTS \
-               -I./include
+              -I./include
 
 check_PROGRAMS = test/tests
 TESTS = $(check_PROGRAMS)
@@ -65,10 +63,8 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/ease.h \
                include/cglm/curve.h \
                include/cglm/bezier.h \
-               include/cglm/applesimd.h \
-               include/cglm/ray.h \
-               include/cglm/affine2d.h
-
+               include/cglm/applesimd.h
+               
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/mat3.h \
@@ -88,9 +84,7 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/sphere.h \
                     include/cglm/call/ease.h \
                     include/cglm/call/curve.h \
-                    include/cglm/call/bezier.h \
-                    include/cglm/call/ray.h \
-                    include/cglm/call/affine2d.h
+                    include/cglm/call/bezier.h
 
 cglm_simddir=$(includedir)/cglm/simd
 cglm_simd_HEADERS = include/cglm/simd/intrin.h \
@@ -101,7 +95,6 @@ cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
 cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
                          include/cglm/simd/sse2/mat4.h \
                          include/cglm/simd/sse2/mat3.h \
-                         include/cglm/simd/sse2/mat2.h \
                          include/cglm/simd/sse2/quat.h
 
 cglm_simd_avxdir=$(includedir)/cglm/simd/avx
@@ -114,7 +107,6 @@ cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/mat3.h \
-                      include/cglm/struct/mat2.h \
                       include/cglm/struct/vec2.h \
                       include/cglm/struct/vec2-ext.h \
                       include/cglm/struct/vec3.h \
@@ -132,9 +124,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/affine2d.h
-                      
+                      include/cglm/struct/curve.h
+
 libcglm_la_SOURCES=\
     src/euler.c \
     src/affine.c \
@@ -154,9 +145,7 @@ libcglm_la_SOURCES=\
     src/sphere.c \
     src/ease.c \
     src/curve.c \
-    src/bezier.c \
-    src/ray.c \
-    src/affine2d.c
+    src/bezier.c
 
 test_tests_SOURCES=\
     test/runner.c \

Package.swift

@@ -1,44 +0,0 @@
-// 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
-)

README.md

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

cglm.podspec

@@ -2,10 +2,10 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.7.9"
-  s.summary      = "📽 Highly Optimized Graphics Math (glm) for C"
+  s.version      = "0.6.1"
+  s.summary      = "📽 Optimized OpenGL/Graphics Math (glm) for C"
   s.description  = <<-DESC
-cglm is math library for graphics programming for C. See the documentation or README for all features.
+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.
                    DESC
 
   s.documentation_url = "http://cglm.readthedocs.io"
@@ -25,13 +25,4 @@ cglm is math library for graphics programming for C. See the documentation or RE
 
   # 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

configure.ac

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

docs/source/affine-mat.rst

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

docs/source/affine.rst

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

docs/source/affine2d.rst

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

docs/source/api.rst

@@ -28,7 +28,6 @@ Follow the :doc:`build` documentation for this
 
    affine
    affine-mat
-   affine2d
    cam
    frustum
    box
@@ -52,5 +51,3 @@ Follow the :doc:`build` documentation for this
    sphere
    curve
    bezier
-   version
-   ray

docs/source/build.rst

@@ -7,81 +7,6 @@ Build cglm
 If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program.
 Just import cglm to your project as dependency / external lib by copy-paste then use it as usual
 
-CMake (All platforms):
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code-block:: bash
-  :linenos:
-
-  $ mkdir build
-  $ cd build
-  $ cmake .. # [Optional] -DCGLM_SHARED=ON
-  $ make
-  $ sudo make install # [Optional]
-
-**make** will build cglm to **build** folder.
-If you don't want to install **cglm** to your system's folder you can get static and dynamic libs in this folder.
-
-**CMake Options:**
-
-.. code-block:: CMake
-  :linenos:
-
-  option(CGLM_SHARED "Shared build" ON)
-  option(CGLM_STATIC "Static build" OFF)
-  option(CGLM_USE_C99 "" OFF) # C11 
-  option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
-
-**Use with your CMake project example**
-
-.. code-block:: CMake
-  :linenos:
-
-  cmake_minimum_required(VERSION 3.8.2)
-  
-  project(<Your Project Name>)
-  
-  add_executable(${PROJECT_NAME} src/main.c)
-  target_link_libraries(${LIBRARY_NAME} PRIVATE
-    cglm)
-  
-  add_subdirectory(external/cglm/)
-
-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):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/cam.rst

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

docs/source/conf.py

@@ -25,7 +25,7 @@
 
 # If your documentation needs a minimal Sphinx version, state it here.
 #
-# needs_sphinx = '3.0'
+# needs_sphinx = '1.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.8.0'
+version = u'0.7.1'
 # The full version, including alpha/beta/rc tags.
-release = u'0.8.0'
+release = u'0.7.1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -197,7 +197,3 @@ 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']

docs/source/features.rst

@@ -1,11 +1,10 @@
 Features
 ================================================================================
 
-* array api and struct api, you can use arrays or structs.
 * general purpose matrix operations (mat4, mat3)
 * chain matrix multiplication (square only)
 * general purpose vector operations (cross, dot, rotate, proj, angle...)
-* affine transformations
+* affine transforms
 * matrix decomposition (extract rotation, scaling factor)
 * optimized affine transform matrices (mul, rigid-body inverse)
 * camera (lookat)
@@ -21,6 +20,4 @@ Features
 * easing functions
 * curves
 * curve interpolation helpers (SMC, deCasteljau...)
-* helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
-* ray intersection helpers
-* and others...
+* and other...

docs/source/io.rst

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

docs/source/mat4.rst

@@ -156,22 +156,16 @@ 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, float last, vec3 dest)
+.. c:function:: void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest)
 
-    | 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()**
+    multiply vector with mat4's mat3 part(rotation)
 
     Parameters:
-      | *[in]*  **m**     mat4(affine transform)
-      | *[in]*  **v**     vec3
-      | *[in]*  **last**  4th item to make it vec4
-      | *[out]* **dest**  result vector (vec3)
+    | *[in]*  **m**     mat4 (left)
+    | *[in]*  **v**     vec3 (right, column vector)
+    | *[out]* **dest**  vec3 (result, column vector)
 
 .. c:function:: void  glm_mat4_trace(mat4 m)
 

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 versions then you
+to define it in build system. If you use pre-compiled verisons then you
 have to compile cglm with **CGLM_ALL_UNALIGNED** macro.
 
 **VERY VERY IMPORTANT:** If you use cglm in multiple projects and
@@ -50,36 +50,3 @@ You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT
 - If **SSE3** is enabled then you can define **CGLM_SSE3_DOT** to force cglm to use **_mm_hadd_ps** instructions.
 
 otherwise cglm will use custom cglm's hadd functions which are optimized too.
-
-Print Options
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-1. **CGLM_DEFINE_PRINTS**
-2. **CGLM_NO_PRINTS_NOOP** (use CGLM_DEFINE_PRINTS)
-
-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
-
-precision.
-
-4. **CGLM_PRINT_MAX_TO_SHORT** 1e5
-
-if a number is greater than this value then %g will be used, since this is shorten print you won't be able to see high precision.
-
-5. **CGLM_PRINT_COLOR**        "\033[36m"
-6. **CGLM_PRINT_COLOR_RESET**  "\033[0m"
-
-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.

docs/source/quat.rst

@@ -374,7 +374,7 @@ Functions documentation
       | *[in]*       **q**      quaternion
       | *[in]*       **pivot**  pivot
 
-.. c:function:: void glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot)
+.. c:function:: void glm_quat_rotate(mat4 m, versor q, mat4 dest)
 
     | rotate NEW transform matrix using quaternion at pivot point
     | this creates rotation matrix, it assumes you don't have a matrix

docs/source/ray.rst

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

docs/source/troubleshooting.rst

@@ -80,19 +80,6 @@ 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?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/util.rst

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

docs/source/vec2.rst

@@ -55,12 +55,12 @@ Functions:
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-.. c:function:: void glm_vec2(float * v, vec2 dest)
+.. c:function:: void glm_vec2(vec4 v4, vec2 dest)
 
-    init vec2 using vec3 or vec4
+    init vec2 using vec3
 
     Parameters:
-      | *[in]*  **v**     vector
+      | *[in]*  **v3**    vector3
       | *[out]* **dest**  destination
 
 .. c:function:: void glm_vec2_copy(vec2 a, vec2 dest)

docs/source/vec3.rst

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

docs/source/version.rst

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

include/cglm/affine.h

@@ -40,6 +40,10 @@
 #include "mat4.h"
 #include "affine-mat.h"
 
+CGLM_INLINE
+void
+glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix
@@ -455,7 +459,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 (assume that the matrix is orthonormal):
+  /* Note from Apple Open Source (asume 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);

include/cglm/affine2d.h

@@ -1,268 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*
- Functions:
-   CGLM_INLINE void glm_translate2d(mat3 m, vec2 v)
-   CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
-   CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
-   CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
-   CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
-   CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
-   CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
-   CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
-   CGLM_INLINE void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
- */
-
-#ifndef cglm_affine2d_h
-#define cglm_affine2d_h
-
-#include "common.h"
-#include "util.h"
-#include "vec2.h"
-#include "mat3.h"
-
-/*!
- * @brief translate existing 2d transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       v  translate vector [x, y]
- */
-CGLM_INLINE
-void
-glm_translate2d(mat3 m, vec2 v) {
-  m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
-  m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
-  m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
-}
-
-/*!
- * @brief translate existing 2d transform matrix by v vector
- *        and store result in dest
- *
- * source matrix will remain same
- *
- * @param[in]  m    affine transfrom
- * @param[in]  v    translate vector [x, y]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
-  glm_mat3_copy(m, dest);
-  glm_translate2d(dest, v);
-}
-
-/*!
- * @brief translate existing 2d transform matrix by x factor
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translate2d_x(mat3 m, float x) {
-  m[2][0] = m[0][0] * x + m[2][0];
-  m[2][1] = m[0][1] * x + m[2][1];
-  m[2][2] = m[0][2] * x + m[2][2];
-}
-
-/*!
- * @brief translate existing 2d transform matrix by y factor
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translate2d_y(mat3 m, float y) {
-  m[2][0] = m[1][0] * y + m[2][0];
-  m[2][1] = m[1][1] * y + m[2][1];
-  m[2][2] = m[1][2] * y + m[2][2];
-}
-
-/*!
- * @brief creates NEW translate 2d transform matrix by v vector
- *
- * @param[out]  m  affine transfrom
- * @param[in]   v  translate vector [x, y]
- */
-CGLM_INLINE
-void
-glm_translate2d_make(mat3 m, vec2 v) {
-  glm_mat3_identity(m);
-  m[2][0] = v[0];
-  m[2][1] = v[1];
-}
-
-/*!
- * @brief scale existing 2d transform matrix by v vector
- *        and store result in dest
- *
- * @param[in]  m    affine transfrom
- * @param[in]  v    scale vector [x, y]
- * @param[out] dest scaled matrix
- */
-CGLM_INLINE
-void
-glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
-  dest[0][0] = m[0][0] * v[0];
-  dest[0][1] = m[0][1] * v[0];
-  dest[0][2] = m[0][2] * v[0];
-  
-  dest[1][0] = m[1][0] * v[1];
-  dest[1][1] = m[1][1] * v[1];
-  dest[1][2] = m[1][2] * v[1];
-  
-  dest[2][0] = m[2][0];
-  dest[2][1] = m[2][1];
-  dest[2][2] = m[2][2];
-}
-
-/*!
- * @brief creates NEW 2d scale matrix by v vector
- *
- * @param[out]  m  affine transfrom
- * @param[in]   v  scale vector [x, y]
- */
-CGLM_INLINE
-void
-glm_scale2d_make(mat3 m, vec2 v) {
-  glm_mat3_identity(m);
-  m[0][0] = v[0];
-  m[1][1] = v[1];
-}
-
-/*!
- * @brief scales existing 2d transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       v  scale vector [x, y]
- */
-CGLM_INLINE
-void
-glm_scale2d(mat3 m, vec2 v) {
-  m[0][0] = m[0][0] * v[0];
-  m[0][1] = m[0][1] * v[0];
-  m[0][2] = m[0][2] * v[0];
-
-  m[1][0] = m[1][0] * v[1];
-  m[1][1] = m[1][1] * v[1];
-  m[1][2] = m[1][2] * v[1];
-}
-
-/*!
- * @brief applies uniform scale to existing 2d transform matrix v = [s, s]
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       s  scale factor
- */
-CGLM_INLINE
-void
-glm_scale2d_uni(mat3 m, float s) {
-  m[0][0] = m[0][0] * s;
-  m[0][1] = m[0][1] * s;
-  m[0][2] = m[0][2] * s;
-
-  m[1][0] = m[1][0] * s;
-  m[1][1] = m[1][1] * s;
-  m[1][2] = m[1][2] * s;
-}
-
-/*!
- * @brief creates NEW rotation matrix by angle around Z axis
- *
- * @param[out] m     affine transfrom
- * @param[in]  angle angle (radians)
- */
-CGLM_INLINE
-void
-glm_rotate2d_make(mat3 m, float angle) {
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  m[0][0] = c;
-  m[0][1] = s;
-  m[0][2] = 0;
-
-  m[1][0] = -s;
-  m[1][1] = c;
-  m[1][2] = 0;
-  
-  m[2][0] = 0.0f;
-  m[2][1] = 0.0f;
-  m[2][2] = 1.0f;
-}
-
-/*!
- * @brief rotate existing 2d transform matrix around Z axis by angle
- *         and store result in same matrix
- *
- * @param[in, out]  m      affine transfrom
- * @param[in]       angle  angle (radians)
- */
-CGLM_INLINE
-void
-glm_rotate2d(mat3 m, float angle) {
-  float m00 = m[0][0],  m10 = m[1][0],
-        m01 = m[0][1],  m11 = m[1][1],
-        m02 = m[0][2],  m12 = m[1][2];
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  m[0][0] = m00 * c + m10 * s;
-  m[0][1] = m01 * c + m11 * s;
-  m[0][2] = m02 * c + m12 * s;
-
-  m[1][0] = m00 * -s + m10 * c;
-  m[1][1] = m01 * -s + m11 * c;
-  m[1][2] = m02 * -s + m12 * c;
-}
-
-/*!
- * @brief rotate existing 2d transform matrix around Z axis by angle
- *        and store result in dest
- *
- * @param[in]  m      affine transfrom
- * @param[in]  angle  angle (radians)
- * @param[out] dest   destination
- */
-CGLM_INLINE
-void
-glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
-  float m00 = m[0][0],  m10 = m[1][0],
-        m01 = m[0][1],  m11 = m[1][1],
-        m02 = m[0][2],  m12 = m[1][2];
-  float c, s;
-
-  s = sinf(angle);
-  c = cosf(angle);
-  
-  dest[0][0] = m00 * c + m10 * s;
-  dest[0][1] = m01 * c + m11 * s;
-  dest[0][2] = m02 * c + m12 * s;
-
-  dest[1][0] = m00 * -s + m10 * c;
-  dest[1][1] = m01 * -s + m11 * c;
-  dest[1][2] = m02 * -s + m12 * c;
-  
-  dest[2][0] = m[2][0];
-  dest[2][1] = m[2][1];
-  dest[2][2] = m[2][2];
-}
-
-#endif /* cglm_affine2d_h */

include/cglm/box.h

@@ -228,8 +228,6 @@ 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
  */
@@ -239,13 +237,13 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
   float dmin;
   int   a, b, c;
 
-  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]);
+  a = s[0] >= box[0][0];
+  b = s[1] >= box[0][1];
+  c = s[2] >= box[0][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));
+  dmin  = glm_pow2(s[0] - box[a][0])
+        + glm_pow2(s[1] - box[b][1])
+        + glm_pow2(s[2] - box[c][2]);
 
   return dmin <= glm_pow2(s[3]);
 }

include/cglm/call.h

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

include/cglm/call/affine2d.h

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

include/cglm/call/io.h

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

include/cglm/call/ray.h

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

include/cglm/cglm.h

@@ -30,7 +30,5 @@
 #include "ease.h"
 #include "curve.h"
 #include "bezier.h"
-#include "ray.h"
-#include "affine2d.h"
 
 #endif /* cglm_h */

include/cglm/common.h

@@ -8,13 +8,7 @@
 #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
+#define _USE_MATH_DEFINES /* for windows */
 
 #include <stdint.h>
 #include <stddef.h>
@@ -23,9 +17,7 @@
 #include <stdbool.h>
 
 #if defined(_MSC_VER)
-#  ifdef CGLM_STATIC
-#    define CGLM_EXPORT
-#  elif defined(CGLM_EXPORTS)
+#  ifdef CGLM_DLL
 #    define CGLM_EXPORT __declspec(dllexport)
 #  else
 #    define CGLM_EXPORT __declspec(dllimport)
@@ -42,12 +34,4 @@
 #include "types.h"
 #include "simd/intrin.h"
 
-#ifndef CGLM_USE_DEFAULT_EPSILON
-#  ifndef GLM_FLT_EPSILON
-#    define GLM_FLT_EPSILON 1e-6
-#  endif
-#else
-#  define GLM_FLT_EPSILON FLT_EPSILON
-#endif
-
 #endif /* cglm_common_h */

include/cglm/euler.h

@@ -18,24 +18,160 @@
    enum glm_euler_seq
 
  Functions:
-   CGLM_INLINE glm_euler_seq glm_euler_order(int newOrder[3]);
-   CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
-   CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_by_order(vec3         angles,
-                                       glm_euler_seq ord,
-                                       mat4         dest);
+   CGLM_INLINE glm_eul_mat4(vec3 ea, int order, mat4 dest)
  */
 
 #ifndef cglm_euler_h
 #define cglm_euler_h
 
 #include "common.h"
+#include "util.h"
+
+/* ---------- Notice for Ken Shoemake's algorithm Implementation -------------*
+ | Ken Shoemake's algorithm impl. is taken from this repo by permission:      |
+ |   https://github.com/erich666/GraphicsGems/blob/master/gemsiv/euler_angle  |
+ |                                                                            |
+ | cglm doesn't claim the ownership of GraphicsGems source codes              |
+ | and the algorithm itself. But cglm may change variable names or some piece |
+ | of codes in order to apply optimizations or to make it usable in cglm.     |
+ |                                                                            |
+ | Related issue: https://github.com/recp/cglm/issues/30                      |
+ |                                                                            |
+ * -------------------------- GraphicsGems EULA ----------------------------- *
+ | Related EULA for GraphicsGems can be found at below, plus in CREDITS:      |
+ |   http://www.realtimerendering.com/resources/GraphicsGems/                 |
+ |                                                                            |
+ | EULA: The Graphics Gems code is copyright-protected. In other words, you   |
+ | cannot claim the text of the code as your own and resell it. Using the     |
+ | code is permitted in any program, product, or library, non-commercial or   |
+ | commercial. Giving credit is not required, though is a nice gesture.       |
+ | The code comes as-is, and if there are any flaws or problems with any Gems |
+ | code, nobody involved with Gems - authors, editors, publishers, or         |
+ | webmasters - are to be held responsible. Basically, don't be a jerk, and   |
+ | remember that anything free comes with no guarantee.                       |
+ * -------------------------------- END --------------------------------------*/
+
+/* Order type constants, constructors, extractors
+ * There are 24 possible conventions, designated by:
+ *	  o EulAxI = axis used initially
+ *	  o EulPar = parity of axis permutation
+ *	  o EulRep = repetition of initial axis as last
+ *	  o EulFrm = frame from which axes are taken
+ * Axes I,J,K will be a permutation of X,Y,Z.
+ * Axis H will be either I or K, depending on EulRep.
+ * Frame S takes axes from initial static frame.
+ * If ord = (AxI=X, Par=Even, Rep=No, Frm=S), then
+ * {a,b,c,ord} means Rz(c)Ry(b)Rx(a), where Rz(c)v
+ * rotates v around Z by c radians.			    
+*/
+
+#define EulRep(ord)  (((unsigned)(ord)>>1)&1)
+#define EulFrm(ord)  ((unsigned)(ord)&1)
+#define EulPar(ord)  (((unsigned)(ord)>>2)&1)
+
+/*! this code is merely a quick (and legal!) way to set arrays,
+    EulSafe being 0,1,2,0 */
+#define EulSafe	     "\000\001\002\000"
+#define EulNext	     "\001\002\000\001"
+#define EulAxI(ord)  ((int)(EulSafe[(((unsigned)(ord)>>3)&3)]))
+#define EulAxJ(ord)  ((int)(EulNext[EulAxI(ord)+(EulPar(ord)==EulParOdd)]))
+#define EulAxK(ord)  ((int)(EulNext[EulAxI(ord)+(EulPar(ord)!=EulParOdd)]))
+#define EulAxH(ord)  ((EulRep(ord)==EulRepNo)?EulAxK(ord):EulAxI(ord))
+
+/*! EulGetOrd unpacks all useful information about order simultaneously. */
+#define EulGetOrd(ord,i,j,k,h,n,s,f)                                          \
+  {unsigned o=(unsigned)ord;f=o&1;o>>=1;s=o&1;o>>=1;\
+    n=o&1;o>>=1;i=EulSafe[o&3];j=EulNext[i+n];k=EulNext[i+1-n];h=s?k:i;}
+
+typedef enum glm_eul_order {
+  /*! Static axes */
+  GLM_EUL_XYZs  = 0,
+  GLM_EUL_XYXs  = 2,
+  GLM_EUL_XZYs  = 4,
+  GLM_EUL_XZXs  = 6,
+  GLM_EUL_YZXs  = 8,
+  GLM_EUL_YZYs  = 10,
+  GLM_EUL_YXZs  = 12,
+  GLM_EUL_YXYs  = 14,
+  GLM_EUL_ZXYs  = 16,
+  GLM_EUL_ZXZs  = 18,
+  GLM_EUL_ZYXs  = 20,
+  GLM_EUL_ZYZs  = 22,
+  
+  /*! Rotating axes */
+  GLM_EUL_ZYXr  = 1,
+  GLM_EUL_XYXr  = 3,
+  GLM_EUL_YZXr  = 5,
+  GLM_EUL_XZXr  = 7,
+  GLM_EUL_XZYr  = 9,
+  GLM_EUL_YZYr  = 11,
+  GLM_EUL_ZXYr  = 13,
+  GLM_EUL_YXYr  = 15,
+  GLM_EUL_YXZr  = 17,
+  GLM_EUL_ZXZr  = 19,
+  GLM_EUL_XYZr  = 21,
+  GLM_EUL_ZYZr  = 23
+} glm_eul_order;
+
+/*!
+ * @brief build matrix from euler angles
+ *
+ * @param[in]  ea     [Xangle, Yangle, Zangle]
+ * @param[out] dest   rotation matrix
+ */
+CGLM_INLINE
+void
+glm_eul_mat4(vec3 ea, glm_eul_order order, mat4 dest) {
+  float ti, tj, th, ci, cj, ch, si, sj, sh, cc, cs, sc, ss;
+  int   i, j, k, h, parOdd, repYes, frmR;
+
+  EulGetOrd(order, i, j, k, h, parOdd, repYes, frmR);
+  
+  if (frmR == 1)
+    glm_swapf(&ea[0], &ea[2]);
+  
+  if (parOdd == 1)
+    glm_vec3_negate(ea);
+  
+  ti = ea[0]; tj = ea[1]; th = ea[2];
+  
+  ci = cosf(ti);  cj = cosf(tj);
+  ch = cosf(th);  si = sinf(ti);
+  sj = sinf(tj);  sh = sinf(th);
+  
+  cc = ci * ch;  cs = ci * sh;
+  sc = si * ch;  ss = si * sh;
+  
+  if (repYes == 1) {
+    dest[i][i] =  cj;
+    dest[i][j] =  sj * si;
+    dest[i][k] =  sj * ci;
+    dest[j][i] =  sj * sh;
+    dest[j][j] = -cj * ss + cc;
+    dest[j][k] = -cj * cs - sc;
+    dest[k][i] = -sj * ch;
+    dest[k][j] =  cj * sc + cs;
+    dest[k][k] =  cj * cc - ss;
+  } else {
+    dest[i][i] =  cj * ch;
+    dest[i][j] =  sj * sc - cs;
+    dest[i][k] =  sj * cc + ss;
+    dest[j][i] =  cj * sh;
+    dest[j][j] =  sj * ss + cc;
+    dest[j][k] =  sj * cs - sc;
+    dest[k][i] = -sj;
+    dest[k][j] =  cj * si;
+    dest[k][k] =  cj * ci;
+  }
+  
+  dest[3][0] = 0.f;
+  dest[3][1] = 0.f;
+  dest[3][2] = 0.f;
+  dest[0][3] = 0.f;
+  dest[1][3] = 0.f;
+  dest[2][3] = 0.f;
+  dest[3][3] = 1.f;
+}
 
 /*!
  * if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
@@ -55,6 +191,8 @@ typedef enum glm_euler_seq {
   GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
 } glm_euler_seq;
 
+typedef glm_euler_seq glm_euler_sq;
+
 CGLM_INLINE
 glm_euler_seq
 glm_euler_order(int ord[3]) {

include/cglm/io.h

@@ -15,130 +15,69 @@
    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_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
 glm_mat4_print(mat4              matrix,
                FILE * __restrict ostream) {
-  char buff[16];
-  int  i, j, cw[4], cwi;
+  int i;
+  int j;
 
 #define m 4
 #define n 4
 
-  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n" , m, n);
-
-  cw[0] = cw[1] = cw[2] = cw[3] = 0;
+  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
 
   for (i = 0; i < m; i++) {
+    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
-      cw[i] = GLM_MAX(cw[i], cwi);
+      fprintf(ostream, "%0.4f", matrix[j][i]);;
+
+      if (j != n - 1)
+        fprintf(ostream, "\t");
     }
+
+    fprintf(ostream, "|\n");
   }
 
-  for (i = 0; i < m; i++) {
-    fprintf(ostream, "  |");
-
-    for (j = 0; j < n; j++)
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
-      else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
-
-    fprintf(ostream, "  |\n");
-  }
-
-  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
+  fprintf(ostream, "\n");
 
 #undef m
 #undef n
 }
 
-
 CGLM_INLINE
 void
 glm_mat3_print(mat3              matrix,
                FILE * __restrict ostream) {
-  char buff[16];
-  int  i, j, cw[4], cwi;
+  int i;
+  int j;
 
 #define m 3
 #define n 3
 
-  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
-
-  cw[0] = cw[1] = cw[2] = 0;
+  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
 
   for (i = 0; i < m; i++) {
+    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
-      cw[i] = GLM_MAX(cw[i], cwi);
+      fprintf(ostream, "%0.4f", matrix[j][i]);;
+
+      if (j != n - 1)
+        fprintf(ostream, "\t");
     }
+
+    fprintf(ostream, "|\n");
   }
 
-  for (i = 0; i < m; i++) {
-    fprintf(ostream, "  |");
-    
-    for (j = 0; j < n; j++)
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
-      else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
-    
-    fprintf(ostream, "  |\n");
-  }
-
-  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
+  fprintf(ostream, "\n");
 
 #undef m
 #undef n
@@ -148,39 +87,27 @@ CGLM_INLINE
 void
 glm_mat2_print(mat2              matrix,
                FILE * __restrict ostream) {
-  char buff[16];
-  int  i, j, cw[4], cwi;
+  int i;
+  int j;
 
 #define m 2
 #define n 2
 
-  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
-
-  cw[0] = cw[1] = 0;
+  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
 
   for (i = 0; i < m; i++) {
+    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
-      cw[i] = GLM_MAX(cw[i], cwi);
+      fprintf(ostream, "%0.4f", matrix[j][i]);;
+
+      if (j != n - 1)
+        fprintf(ostream, "\t");
     }
+
+    fprintf(ostream, "|\n");
   }
 
-  for (i = 0; i < m; i++) {
-    fprintf(ostream, "  |");
-    
-    for (j = 0; j < n; j++)
-      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
-      else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
-    
-    fprintf(ostream, "  |\n");
-  }
-
-  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
+  fprintf(ostream, "\n");
 
 #undef m
 #undef n
@@ -194,16 +121,16 @@ glm_vec4_print(vec4              vec,
 
 #define m 4
 
-  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
+  fprintf(ostream, "Vector (float%d):\n\t|", m);
 
   for (i = 0; i < m; i++) {
-    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    else
-      fprintf(ostream, " % g", vec[i]);
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
   }
 
-  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+  fprintf(ostream, "|\n\n");
 
 #undef m
 }
@@ -216,16 +143,16 @@ glm_vec3_print(vec3              vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
+  fprintf(ostream, "Vector (float%d):\n\t|", m);
 
   for (i = 0; i < m; i++) {
-    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    else
-      fprintf(ostream, " % g", vec[i]);
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
   }
 
-  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+  fprintf(ostream, "|\n\n");
 
 #undef m
 }
@@ -238,12 +165,16 @@ glm_ivec3_print(ivec3             vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (int%d): " CGLM_PRINT_COLOR "\n  (", m);
+  fprintf(ostream, "Vector (int%d):\n\t|", m);
 
-  for (i = 0; i < m; i++)
-    fprintf(ostream, " % d", vec[i]);
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "%d", vec[i]);
 
-  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+    if (i != m - 1)
+      fprintf(ostream, "\t");
+  }
+
+  fprintf(ostream, "|\n\n");
   
 #undef m
 }
@@ -256,16 +187,16 @@ glm_vec2_print(vec2              vec,
 
 #define m 2
 
-  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
+  fprintf(ostream, "Vector (float%d):\n\t|", m);
 
   for (i = 0; i < m; i++) {
-    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    else
-      fprintf(ostream, " % g", vec[i]);
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
   }
 
-  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+  fprintf(ostream, "|\n\n");
 
 #undef m
 }
@@ -278,17 +209,16 @@ glm_versor_print(versor            vec,
 
 #define m 4
 
-  fprintf(ostream, "Quaternion (float%d): " CGLM_PRINT_COLOR "\n  (", m);
+  fprintf(ostream, "Versor (float%d):\n\t|", m);
 
   for (i = 0; i < m; i++) {
-    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    else
-      fprintf(ostream, " % g", vec[i]);
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
   }
 
-
-  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+  fprintf(ostream, "|\n\n");
 
 #undef m
 }
@@ -302,43 +232,24 @@ glm_aabb_print(vec3                    bbox[2],
 
 #define m 3
 
-  fprintf(ostream, "AABB (%s): " CGLM_PRINT_COLOR "\n", tag ? tag: "float");
+  fprintf(ostream, "AABB (%s):\n", tag ? tag: "float");
 
   for (i = 0; i < 2; i++) {
-    fprintf(ostream, "  (");
-    
+    fprintf(ostream, "\t|");
+
     for (j = 0; j < m; j++) {
-      if (bbox[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, bbox[i][j]);
-      else
-        fprintf(ostream, " % g", bbox[i][j]);
+      fprintf(ostream, "%0.4f", bbox[i][j]);
+
+      if (j != m - 1)
+        fprintf(ostream, "\t");
     }
 
-    fprintf(ostream, "  )\n");
+    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
+  fprintf(ostream, "\n");
 
 #undef m
 }
 
-#else
-
-#include "common.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/* NOOP: Remove print from DEBUG */
-#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 */

include/cglm/mat2.h

@@ -56,7 +56,7 @@
 CGLM_INLINE
 void
 glm_mat2_copy(mat2 mat, mat2 dest) {
-  glm_vec4_ucopy(mat[0], dest[0]);
+  glm_vec4_copy(mat[0], dest[0]);
 }
 
 /*!
@@ -216,16 +216,7 @@ glm_mat2_trace(mat2 m) {
 CGLM_INLINE
 void
 glm_mat2_scale(mat2 m, float s) {
-#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
+  glm_vec4_scale(m[0], s, m[0]);
 }
 
 /*!

include/cglm/mat3.h

@@ -228,11 +228,9 @@ glm_mat3_transpose(mat3 m) {
 CGLM_INLINE
 void
 glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
-  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);
+  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];
 }
 
 /*!

include/cglm/mat4.h

@@ -358,8 +358,6 @@ 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];
@@ -478,8 +476,6 @@ 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];
@@ -502,8 +498,6 @@ 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);
@@ -542,7 +536,12 @@ glm_mat4_scale(mat4 m, float s) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_scale_sse2(m, s);
 #elif defined(CGLM_NEON_FP)
-  glm_mat4_scale_neon(m, 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));
 #else
   glm_mat4_scale_p(m, s);
 #endif

include/cglm/quat.h

@@ -63,6 +63,10 @@
 #  include "simd/sse2/quat.h"
 #endif
 
+CGLM_INLINE
+void
+glm_mat4_identity(mat4 mat);
+
 CGLM_INLINE
 void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);

include/cglm/ray.h

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

include/cglm/simd/neon/mat4.h

@@ -12,32 +12,6 @@
 #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) {
@@ -79,27 +53,5 @@ 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 */

include/cglm/simd/x86.h

@@ -175,7 +175,7 @@ glmm_load3(float v[3]) {
   __m128i xy;
   __m128  z;
 
-  xy = _mm_loadl_epi64(CGLM_CASTPTR_ASSUME_ALIGNED(v, const __m128i));
+  xy = _mm_loadl_epi64((const __m128i *)v);
   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(CGLM_CASTPTR_ASSUME_ALIGNED(v, __m64), vx);
+  _mm_storel_pi((__m64 *)&v[0], vx);
   _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
 }
 

include/cglm/struct.h

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

include/cglm/struct/affine.h

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

include/cglm/struct/affine2d.h

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

include/cglm/struct/mat2.h

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

include/cglm/struct/sphere.h

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

include/cglm/struct/vec2.h

@@ -66,7 +66,7 @@
 /*!
  * @brief init vec2 using vec2
  *
- * @param[in]  v3   vector3
+ * @param[in]  v4   vector3
  * @returns         destination
  */
 CGLM_INLINE
@@ -455,18 +455,18 @@ glms_vec2_normalize(vec2s v) {
 }
 
 /*!
- * @brief rotate vec2 by angle using Rodrigues' rotation formula
+ * @brief rotate vec2 around axis by angle using Rodrigues' rotation formula
  *
  * @param[in]     v     vector
+ * @param[in]     axis  axis vector (must be unit vector)
  * @param[in]     angle angle by radians
  * @returns             rotated vector
  */
 CGLM_INLINE
 vec2s
-glms_vec2_rotate(vec2s v, float angle) {
-  vec2s r;
-  glm_vec2_rotate(v.raw, angle, r.raw);
-  return r;
+glms_vec2_rotate(vec2s v, float angle, vec2s axis) {
+  glm_vec2_rotate(v.raw, angle, axis.raw);
+  return v;
 }
 
 /**

include/cglm/types.h

@@ -32,16 +32,6 @@
 #  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];

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) <= GLM_FLT_EPSILON;
+  return fabsf(a - b) <= FLT_EPSILON;
 }
 
 /*!
@@ -322,7 +322,7 @@ glm_percent(float from, float to, float current) {
 CGLM_INLINE
 float
 glm_percentc(float from, float to, float current) {
-  return glm_clamp_zo(glm_percent(from, to, current));
+  return glm_clamp(glm_percent(from, to, current), 0.0f, 1.0f);
 }
 
 /*!

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) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= GLM_FLT_EPSILON;
+  return fabsf(v[0] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= FLT_EPSILON;
 }
 
 /*!
@@ -73,7 +73,7 @@ glm_vec2_eq_eps(vec2 v, float val) {
 CGLM_INLINE
 bool
 glm_vec2_eq_all(vec2 v) {
-  return glm_vec2_eq_eps(v, v[0]);
+  return v[0] == v[1];
 }
 
 /*!
@@ -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]) <= GLM_FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= FLT_EPSILON;
 }
 
 /*!

include/cglm/vec3-ext.h

@@ -81,9 +81,9 @@ glm_vec3_eq(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_eps(vec3 v, float val) {
-  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[2] - val) <= GLM_FLT_EPSILON;
+  return fabsf(v[0] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= FLT_EPSILON
+         && fabsf(v[2] - val) <= FLT_EPSILON;
 }
 
 /*!
@@ -94,7 +94,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_all(vec3 v) {
-  return glm_vec3_eq_eps(v, v[0]);
+  return v[0] == v[1] && v[0] == v[2];
 }
 
 /*!
@@ -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]) <= GLM_FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= 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]), 0.999999940395355224609375f);
-  dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
-  dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
+  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);
 }
 
 /*!

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) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[2] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[3] - val) <= GLM_FLT_EPSILON;
+  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;
 }
 
 /*!
@@ -106,7 +106,9 @@ glm_vec4_eq_eps(vec4 v, float val) {
 CGLM_INLINE
 bool
 glm_vec4_eq_all(vec4 v) {
-  return glm_vec4_eq_eps(v, v[0]);
+  return v[0] == v[1]
+         && v[0] == v[2]
+         && v[0] == v[3];
 }
 
 /*!
@@ -133,10 +135,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]) <= 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;
+  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;
 }
 
 /*!
@@ -268,10 +270,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]), 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);
+  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);
 }
 
 /*!

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),
-                            vmulq_f32(vld1q_f32(a),
+                            vsubq_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, vnegq_f32(vld1q_f32(v)));
+  vst1q_f32(dest, veorq_s32(vld1q_f32(v), vdupq_n_f32(-0.0f)));
 #else
   dest[0] = -v[0];
   dest[1] = -v[1];

include/cglm/version.h

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

include/module.modulemap

@@ -1,14 +0,0 @@
-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 *
-}

meson.build

@@ -1,108 +0,0 @@
-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

meson_options.txt

@@ -1,2 +0,0 @@
-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')

src/affine2d.c

@@ -1,81 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "../include/cglm/cglm.h"
-#include "../include/cglm/call.h"
-
-CGLM_EXPORT
-void
-glmc_translate2d_make(mat3 m, vec2 v) {
-  glm_translate2d_make(m, v);
-}
-
-CGLM_EXPORT
-void
-glmc_translate2d_to(mat3 m, vec2 v, mat3 dest) {
-  glm_translate2d_to(m, v, dest);
-}
-
-CGLM_EXPORT
-void
-glmc_translate2d(mat3 m, vec2 v) {
-  glm_translate2d(m, v);
-}
-
-CGLM_EXPORT
-void
-glmc_translate2d_x(mat3 m, float to) {
-  glm_translate2d_x(m, to);
-}
-
-CGLM_EXPORT
-void
-glmc_translate2d_y(mat3 m, float to) {
-  glm_translate2d_y(m, to);
-}
-
-CGLM_EXPORT
-void
-glmc_scale2d_to(mat3 m, vec2 v, mat3 dest) {
-  glm_scale2d_to(m, v, dest);
-}
-
-CGLM_EXPORT
-void
-glmc_scale2d_make(mat3 m, vec2 v) {
-  glm_scale2d_make(m, v);
-}
-
-CGLM_EXPORT
-void
-glmc_scale2d(mat3 m, vec2 v) {
-  glm_scale2d(m, v);
-}
-
-CGLM_EXPORT
-void
-glmc_scale2d_uni(mat3 m, float s) {
-  glm_scale2d_uni(m, s);
-}
-
-CGLM_EXPORT
-void
-glmc_rotate2d_make(mat3 m, float angle) {
-  glm_rotate2d_make(m, angle);
-}
-
-CGLM_EXPORT
-void
-glmc_rotate2d(mat3 m, float angle) {
-  glm_rotate2d(m, angle);
-}
-
-CGLM_EXPORT
-void
-glmc_rotate2d_to(mat3 m, float angle, mat3 dest) {
-  glm_rotate2d_to(m, angle, dest);
-}

src/config.h

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

src/io.c

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

src/ray.c

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

src/swift/empty.c

@@ -1 +0,0 @@
-// 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

test/CMakeLists.txt

@@ -1,44 +0,0 @@
-cmake_minimum_required(VERSION 3.8.2)
-
-# List all files containing tests. (Change as needed)
-set(TESTFILES
-  runner.c
-  src/test_euler.c
-  src/test_bezier.c
-  src/test_cam.c
-  src/test_struct.c
-  src/test_clamp.c
-  src/test_common.c
-  src/tests.c
-  )
-
-set(TEST_MAIN tests)
-set(TEST_RUNNER_PARAMS "")
-
-add_executable(${TEST_MAIN} ${TESTFILES})
-target_compile_definitions(${TEST_MAIN} PRIVATE CGLM_DEFINE_PRINTS=1)
-
-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
-  )
-
-set_target_properties(${TEST_MAIN} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
-
-if(LDFLAGS)
-  target_compile_options(${TEST_MAIN} PRIVATE ${LDFLAGS})
-endif()
-
-add_test(
-    NAME cglm.${TEST_MAIN}
-    COMMAND ${TEST_MAIN} ${TEST_RUNNER_PARAMS})
-
-add_custom_target(check
-  make
-  COMMAND ${CMAKE_CTEST_COMMAND} -V
-  DEPENDS cglm)

test/include/common.h

@@ -8,18 +8,6 @@
 #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>
 #include <string.h>
@@ -42,8 +30,6 @@ 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 */
@@ -62,28 +48,6 @@ typedef struct test_entry_t {
 #define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
 #define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */
 
-#else
-
-#define RESET
-#define BLACK
-#define RED
-#define GREEN
-#define YELLOW
-#define BLUE
-#define MAGENTA
-#define CYAN
-#define WHITE
-#define BOLDBLACK
-#define BOLDRED
-#define BOLDGREEN
-#define BOLDYELLOW
-#define BOLDBLUE
-#define BOLDMAGENTA
-#define BOLDCYAN
-#define BOLDWHITE
-
-#endif
-
 #define TEST_DECLARE(FUN) test_status_t test_ ## FUN(void);
 #define TEST_ENTRY(FUN)   { #FUN, test_ ## FUN, 0, 0 },
 #define TEST_LIST         static test_entry_t tests[] = 

test/runner.c

@@ -18,8 +18,6 @@ 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;

test/src/test_affine2d.h

@@ -1,310 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "test_common.h"
-
-TEST_IMPL(GLM_PREFIX, translate2d) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(translate2d)(m1, (vec2){13.0f, 11.0f});
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 15.0f))
-  ASSERT(test_eq(v2[1], 14.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(translate2d)(m1, (vec2){1.0f, -1.0f});
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], 16.0f))
-  ASSERT(test_eq(v2[1], 13.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, translate2d_to) {
-  mat3 m1, m2;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
-  glm_mat3_mulv(m2, v1, v2);
-
-  ASSERT(test_eq(v2[0], 15.0f))
-  ASSERT(test_eq(v2[1], 14.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_to)(m1, (vec2){1.0f, -1.0f}, m2);
-  glm_mat3_mulv(m2, v2, v2);
-
-  ASSERT(test_eq(v2[0], 16.0f))
-  ASSERT(test_eq(v2[1], 13.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, translate2d_x) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_x)(m1, 13.0f);
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 15.0f))
-  ASSERT(test_eq(v2[1], 3.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_x)(m1, -1.0f);
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], 14.0f))
-  ASSERT(test_eq(v2[1], 3.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, translate2d_y) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_y)(m1, 11.0f);
-  glm_mat3_mulv(m1, v1, v2);
-  
-
-  ASSERT(test_eq(v2[0], 2.0f))
-  ASSERT(test_eq(v2[1], 14.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_y)(m1, -1.0f);
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], 2.0f))
-  ASSERT(test_eq(v2[1], 13.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-  
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, translate2d_make) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_make)(m1, (vec2){13.0f, 11.0f});
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 15.0f))
-  ASSERT(test_eq(v2[1], 14.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(translate2d_make)(m1, (vec2){-1.0f, -5.0f});
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], 14.0f))
-  ASSERT(test_eq(v2[1], 9.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, scale2d_to) {
-  mat3 m1, m2;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(scale2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
-  glm_mat3_mulv(m2, v1, v2);
-
-  ASSERT(test_eq(v2[0], 26.0f))
-  ASSERT(test_eq(v2[1], 33.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(scale2d_to)(m1, (vec2){-1.0f, -5.0f}, m2);
-  glm_mat3_mulv(m2, v2, v2);
-
-  ASSERT(test_eq(v2[0], -26.0f))
-  ASSERT(test_eq(v2[1], -165.0f))
-  ASSERT(test_eq(v2[2],  1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, scale2d_make) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  GLM(scale2d_make)(m1, (vec2){13.0f, 11.0f});
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 26.0f))
-  ASSERT(test_eq(v2[1], 33.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  GLM(scale2d_make)(m1, (vec3){-1.0f, -5.0f});
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], -26.0f))
-  ASSERT(test_eq(v2[1], -165.0f))
-  ASSERT(test_eq(v2[2],  1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, scale2d) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(scale2d)(m1, (vec2){13.0f, 11.0f});
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 26.0f))
-  ASSERT(test_eq(v2[1], 33.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(scale2d)(m1, (vec2){-1.0f, -5.0f});
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], -26.0f))
-  ASSERT(test_eq(v2[1], -165.0f))
-  ASSERT(test_eq(v2[2],  1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, scale2d_uni) {
-  mat3 m1;
-  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
-
-  glm_mat3_identity(m1);
-  GLM(scale2d_uni)(m1, 13.0f);
-  glm_mat3_mulv(m1, v1, v2);
-
-  ASSERT(test_eq(v2[0], 26.0f))
-  ASSERT(test_eq(v2[1], 39.0f))
-  ASSERT(test_eq(v2[2], 1.0f))
-
-  glm_mat3_identity(m1);
-  GLM(scale2d_uni)(m1, -5.0f);
-  glm_mat3_mulv(m1, v2, v2);
-
-  ASSERT(test_eq(v2[0], -130.0f))
-  ASSERT(test_eq(v2[1], -195.0f))
-  ASSERT(test_eq(v2[2],  1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, rotate2d_make) {
-  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
-  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
-
-  GLM(rotate2d_make)(m1, GLM_PI_2f);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0], -1.0f))
-  ASSERT(test_eq(v1[1],  0.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-  
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d_make)(m1, -GLM_PI_2f);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0],  1.0f))
-  ASSERT(test_eq(v1[1],  0.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d_make)(m1, GLM_PIf);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0],  0.0f))
-  ASSERT(test_eq(v1[1], -1.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, rotate2d) {
-  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
-  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
-
-  GLM(rotate2d)(m1, GLM_PI_2f);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0], -1.0f))
-  ASSERT(test_eq(v1[1],  0.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-  
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d)(m1, GLM_PI_2f);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0],  0.0f))
-  ASSERT(test_eq(v1[1], -1.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d)(m1, GLM_PI_2f);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0], 1.0f))
-  ASSERT(test_eq(v1[1], 0.0f))
-  ASSERT(test_eq(v1[2], 1.0f))
-
-  TEST_SUCCESS
-}
-
-TEST_IMPL(GLM_PREFIX, rotate2d_to) {
-  mat3 m1 = GLM_MAT3_IDENTITY_INIT, m2;
-  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
-
-  GLM(rotate2d_to)(m1, GLM_PI_2f, m1);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0], -1.0f))
-  ASSERT(test_eq(v1[1],  0.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-  
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d_to)(m1, GLM_PI_2f, m2);
-  glm_mat3_mulv(m2, v1, v1);
-
-  ASSERT(test_eq(v1[0],  0.0f))
-  ASSERT(test_eq(v1[1], -1.0f))
-  ASSERT(test_eq(v1[2],  1.0f))
-
-  glm_vec3_copy(v2, v1);
-
-  GLM(rotate2d_to)(m2, GLM_PI_2f, m1);
-  glm_mat3_mulv(m1, v1, v1);
-
-  ASSERT(test_eq(v1[0], 1.0f))
-  ASSERT(test_eq(v1[1], 0.0f))
-  ASSERT(test_eq(v1[2], 1.0f))
-
-  TEST_SUCCESS
-}

test/src/test_cam.c

@@ -35,9 +35,9 @@ TEST_IMPL(camera_decomp) {
   farVal  = 100.0f;
 
   glm_perspective(fovy, aspect, nearVal, farVal, proj);
-  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < 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)
+  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)
 
   glm_persp_sizes(proj, fovy, sizes);
 

test/src/test_camera.h

@@ -1,68 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "test_common.h"
-
-TEST_IMPL(GLM_PREFIX, frustum) {
-  mat4  proj;
-  vec4  vp = {0.0f, 0.0f, 800.0f, 600.0f};
-  float left, right, top, bottom, znear, zfar;
-  
-  znear  =  0.1f;
-  zfar   =  100.0f;
-  left   = -100.0f;
-  right  =  100.0f;
-  bottom = -100.0f;
-  top    =  100.0f;
-  
-  GLM(frustum)(left, right, bottom, top, znear, zfar, proj);
-  
-  ASSERT(test_eq(proj[0][1], 0.0f))
-  ASSERT(test_eq(proj[0][2], 0.0f))
-  ASSERT(test_eq(proj[0][3], 0.0f))
-
-  ASSERT(test_eq(proj[1][0], 0.0f))
-  ASSERT(test_eq(proj[1][2], 0.0f))
-  ASSERT(test_eq(proj[1][3], 0.0f))
-
-  ASSERT(test_eq(proj[2][3], -1.0f))
-
-  ASSERT(test_eq(proj[3][0], 0.0f))
-  ASSERT(test_eq(proj[3][1], 0.0f))
-  ASSERT(test_eq(proj[3][3], 0.0f))
-
-  vec4  v1 = {1.0f, 20.0f, znear};
-  vec4  v2 = {1.0f, 20.0f, zfar};
-  vec4  v3, v4;
-
-  /* perspective test */
-  GLM(mat4_mulv)(proj, v1, v3);
-  GLM(project)(v3, proj, vp, v3);
-  
-  ASSERT(v3[0] > v1[0])
-  ASSERT(v3[1] > v1[1])
-  
-  GLM(mat4_mulv)(proj, v2, v4);
-  GLM(project)(v4, proj, vp, v4);
-  
-  ASSERT(v4[0] < v3[0])
-  ASSERT(v4[1] < v3[1])
-  
-  /* not infinity */
-  ASSERT(!GLM(vec4_isinf)(proj[0]))
-  ASSERT(!GLM(vec4_isinf)(proj[1]))
-  ASSERT(!GLM(vec4_isinf)(proj[2]))
-  ASSERT(!GLM(vec4_isinf)(proj[3]))
-  
-  /* not NaN */
-  ASSERT(!GLM(vec4_isnan)(proj[0]))
-  ASSERT(!GLM(vec4_isnan)(proj[1]))
-  ASSERT(!GLM(vec4_isnan)(proj[2]))
-  ASSERT(!GLM(vec4_isnan)(proj[3]))
-
-  TEST_SUCCESS
-}

test/src/test_common.h

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

test/src/test_ray.h

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

test/src/test_struct.c

@@ -1,9 +1,9 @@
 /*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
+* 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/src/tests.c

@@ -22,10 +22,7 @@
 #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
@@ -46,10 +43,7 @@
 #include "test_project.h"
 #include "test_plane.h"
 #include "test_affine.h"
-#include "test_affine2d.h"
 #include "test_affine_mat.h"
-#include "test_ray.h"
-#include "test_camera.h"
 
 #undef GLM
 #undef GLM_PREFIX

test/tests.h

@@ -70,33 +70,6 @@ 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)
@@ -226,10 +199,6 @@ 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)
@@ -249,10 +218,6 @@ TEST_DECLARE(clamp)
 /* euler */
 TEST_DECLARE(euler)
 
-/* ray */
-TEST_DECLARE(glm_ray_triangle)
-TEST_DECLARE(glmc_ray_triangle)
-
 /* quat */
 TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY_INIT)
 TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY)
@@ -791,34 +756,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_uniscaled)
   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)
@@ -948,10 +886,6 @@ 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)
@@ -971,10 +905,6 @@ TEST_LIST {
   /* euler */
   TEST_ENTRY(euler)
   
-  /* ray */
-  TEST_ENTRY(glm_ray_triangle)
-  TEST_ENTRY(glmc_ray_triangle)
-
   /* quat */
   TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY_INIT)
   TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY)
@@ -1054,7 +984,6 @@ TEST_LIST {
   /* bezier */
   TEST_ENTRY(bezier)
 
-  /* vec2 */
   /* Macros */
 
   TEST_ENTRY(MACRO_GLM_VEC2_ONE_INIT)
@@ -1133,6 +1062,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec2_lerp)
 
   /* vec3 */
+
   /* Macros */
 
   TEST_ENTRY(MACRO_GLM_VEC3_ONE_INIT)
@@ -1298,8 +1228,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec3_sqrt)
 
   /* vec4 */
-  /* Macros */
-
+  
   TEST_ENTRY(MACRO_GLM_VEC4_ONE_INIT)
   TEST_ENTRY(MACRO_GLM_VEC4_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_VEC4_ONE)

win/cglm-test.vcxproj

@@ -31,9 +31,7 @@
   <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" />
@@ -44,7 +42,6 @@
     <ClInclude Include="..\test\src\test_vec2.h" />
     <ClInclude Include="..\test\src\test_vec3.h" />
     <ClInclude Include="..\test\src\test_vec4.h" />
-    <ClInclude Include="..\test\src\test_ray.h" />
     <ClInclude Include="..\test\tests.h" />
   </ItemGroup>
   <ItemGroup>
@@ -147,7 +144,6 @@
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -165,7 +161,6 @@
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

win/cglm-test.vcxproj.filters

@@ -79,14 +79,5 @@
     <ClInclude Include="..\test\src\test_vec2.h">
       <Filter>src</Filter>
     </ClInclude>
-    <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>

win/cglm.vcxproj

@@ -20,7 +20,6 @@
   </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" />
@@ -35,7 +34,6 @@
     <ClCompile Include="..\src\plane.c" />
     <ClCompile Include="..\src\project.c" />
     <ClCompile Include="..\src\quat.c" />
-    <ClCompile Include="..\src\ray.c" />
     <ClCompile Include="..\src\sphere.c" />
     <ClCompile Include="..\src\vec2.c" />
     <ClCompile Include="..\src\vec3.c" />
@@ -44,13 +42,11 @@
   <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" />
@@ -65,7 +61,6 @@
     <ClInclude Include="..\include\cglm\call\plane.h" />
     <ClInclude Include="..\include\cglm\call\project.h" />
     <ClInclude Include="..\include\cglm\call\quat.h" />
-    <ClInclude Include="..\include\cglm\call\ray.h" />
     <ClInclude Include="..\include\cglm\call\sphere.h" />
     <ClInclude Include="..\include\cglm\call\vec2.h" />
     <ClInclude Include="..\include\cglm\call\vec3.h" />
@@ -85,14 +80,12 @@
     <ClInclude Include="..\include\cglm\plane.h" />
     <ClInclude Include="..\include\cglm\project.h" />
     <ClInclude Include="..\include\cglm\quat.h" />
-    <ClInclude Include="..\include\cglm\ray.h" />
     <ClInclude Include="..\include\cglm\simd\arm.h" />
     <ClInclude Include="..\include\cglm\simd\avx\affine.h" />
     <ClInclude Include="..\include\cglm\simd\avx\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\intrin.h" />
     <ClInclude Include="..\include\cglm\simd\neon\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\affine.h" />
-    <ClInclude Include="..\include\cglm\simd\sse2\mat2.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat3.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\quat.h" />
@@ -100,7 +93,6 @@
     <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" />
@@ -209,7 +201,7 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
       <DebugInformationFormat>None</DebugInformationFormat>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
       <PrecompiledHeaderFile />
@@ -225,7 +217,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
       <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <WholeProgramOptimization>true</WholeProgramOptimization>
@@ -246,12 +238,11 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
       <DebugInformationFormat>None</DebugInformationFormat>
       <PrecompiledHeaderFile />
       <CompileAs>CompileAsC</CompileAs>
       <EnablePREfast>true</EnablePREfast>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -266,12 +257,11 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
       <DebugInformationFormat>None</DebugInformationFormat>
       <PrecompiledHeaderFile />
       <CompileAs>CompileAsC</CompileAs>
       <EnablePREfast>true</EnablePREfast>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

win/cglm.vcxproj.filters

@@ -92,12 +92,6 @@
     <ClCompile Include="..\src\vec2.c">
       <Filter>src</Filter>
     </ClCompile>
-    <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">
@@ -130,9 +124,6 @@
     <ClInclude Include="..\include\cglm\call\vec4.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
-    <ClInclude Include="..\include\cglm\call\ray.h">
-      <Filter>include\cglm\call</Filter>
-    </ClInclude>
     <ClInclude Include="..\include\cglm\simd\avx\affine.h">
       <Filter>include\cglm\simd\avx</Filter>
     </ClInclude>
@@ -250,9 +241,6 @@
     <ClInclude Include="..\include\cglm\ease.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
-    <ClInclude Include="..\include\cglm\ray.h">
-      <Filter>include\cglm</Filter>
-    </ClInclude>
     <ClInclude Include="..\include\cglm\simd\arm.h">
       <Filter>include\cglm\simd</Filter>
     </ClInclude>
@@ -358,17 +346,5 @@
     <ClInclude Include="..\include\cglm\struct\vec2-ext.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
-    <ClInclude Include="..\include\cglm\simd\sse2\mat2.h">
-      <Filter>include\cglm\simd\sse2</Filter>
-    </ClInclude>
-    <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>