pre-compiled version

README.md

@@ -20,29 +20,35 @@ The original glm library is for C++ only (templates, namespaces, classes...), th
 
 ##Features
 - general purpose matrix operations (mat4, mat3)
+- chain matrix multiplication (square only)
 - general purpose vector operations (cross, dot, ...)
 - affine transforms
+- matrix decomposition (extract rotation, scaling factor)
 - optimized affine transform matrices (mul, rigid-body inverse)
 - camera (lookat)
 - projections (ortho, perspective)
 - quaternions
-- euler angles / yaw-pitch-roll
+- euler angles / yaw-pitch-roll to matrix
+- extract euler angles
+- inline or pre-compiled function call
 
 <hr />
 
-This library is header only so you dont need link to application. All functions are marked inline (always_inline) so compiler probably will inline all these functions
+You have two option to call a function/operation: inline or library call (link)
+Almost all functions are marked inline (always_inline) so compiler probably will inline. 
+To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`. 
 
+```C
+  #include <cglm.h>        /* for inline */
+  #include <cglm-call.h>   /* for library call (this also includes cglm.h) */
+
+  mat4 rot, trans, rt;
+  /* ... */
+  glm_mul(trans, rot, rt);  /* inline */
+  glmc_mul(trans, rot, rt); /* call from library */
+```
 Most of math functions are optimized manualy with SSE2 if available, if not? Dont worry there are non-sse versions of all operations
 
-This library provides:
-
-- Simple usage
-- Small memory footprint
-- The codes are small and more readable than C++ templates, metafuncs
-- Optimized operations with SIMD and non-SIMD
-- All operations are inline (if compiler will do), no function call overhead
-- Chain matrix multiplication (square only)
-
 You can pass matrices and vectors as array to functions rather than get address.
 
 ```C
@@ -69,8 +75,23 @@ glm_inv_tr(modelMat);
 ##License
 MIT. check the LICENSE file
 
-##Install
-Import the library to your include folder, thats it!
+## Build
+
+### Unix (Autotools)
+
+```text
+$ sh autogen.sh
+$ ./configure
+$ make
+$ make install
+$ [sudo] make install
+```
+
+### Windows (MSBuild)
+
+```text
+TODO:
+```
 
 ##Notes
 

autogen.sh

@@ -0,0 +1,21 @@
+#! /bin/sh
+#
+# Copyright (c), Recep Aslantas.
+#
+# MIT License (MIT), http://opensource.org/licenses/MIT
+# Full license can be found in the LICENSE file
+#
+
+cd `dirname "$0"`
+
+if [ "`uname`" = "Darwin" ]; then
+  libtoolBin=$(which glibtoolize)
+  libtoolBinDir=$(dirname "${libtoolBin}")
+  ln -s $libtoolBin "${libtoolBinDir}/libtoolize"
+fi
+
+autoheader
+libtoolize
+aclocal -I m4
+autoconf
+automake --add-missing --copy

configure.ac

@@ -0,0 +1,57 @@
+#*****************************************************************************
+# Copyright (c), Recep Aslantas.                                             *
+#                                                                            *
+# MIT License (MIT), http://opensource.org/licenses/MIT                      *
+# Full license can be found in the LICENSE file                              *
+#                                                                            *
+#*****************************************************************************
+
+AC_PREREQ([2.69])
+AC_INIT([cglm], [0.1.0], [info@recp.me])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
+
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_SRCDIR([src/])
+AC_CONFIG_HEADERS([config.h])
+
+# Checks for programs.
+AC_PROG_CC
+AM_PROG_CC_C_O
+
+AC_PROG_INSTALL
+AM_PROG_AR
+
+AC_ENABLE_SHARED
+AC_ENABLE_STATIC
+
+LT_INIT
+
+# Checks for libraries.
+AC_CHECK_LIB([m], [floor])
+
+AC_SYS_LARGEFILE
+
+# Checks for header files.
+AC_CHECK_HEADERS([limits.h \
+                  stddef.h \
+                  stdint.h \
+                  stdlib.h \
+                  string.h ])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_CHECK_HEADER_STDBOOL
+AC_C_INLINE
+AC_TYPE_INT32_T
+AC_TYPE_INT64_T
+AC_TYPE_SIZE_T
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+AC_TYPE_UINT64_T
+AC_TYPE_UINT8_T
+
+# Checks for library functions.
+AC_FUNC_ERROR_AT_LINE
+
+AC_CONFIG_FILES([makefile])
+
+AC_OUTPUT

include/call/cglmc-affine.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_affine_h
+#define cglmc_affine_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_translate_to(mat4 m, vec3 v, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_translate(mat4 m, vec3 v);
+
+CGLM_EXPORT
+void
+glmc_translate_x(mat4 m, float to);
+
+CGLM_EXPORT
+void
+glmc_translate_y(mat4 m, float to);
+
+CGLM_EXPORT
+void
+glmc_translate_z(mat4 m, float to);
+
+CGLM_EXPORT
+void
+glmc_scale_to(mat4 m, vec3 v, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_scale(mat4 m, vec3 v);
+
+CGLM_EXPORT
+void
+glmc_scale1(mat4 m, float s);
+
+CGLM_EXPORT
+void
+glmc_rotate_x(mat4 m, float rad, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotate_y(mat4 m, float rad, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotate_z(mat4 m, float rad, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotate_ndc_make(mat4 m, float angle, vec3 axis_ndc);
+
+CGLM_EXPORT
+void
+glmc_rotate_make(mat4 m, float angle, vec3 axis);
+
+CGLM_EXPORT
+void
+glmc_rotate_ndc(mat4 m, float angle, vec3 axis_ndc);
+
+CGLM_EXPORT
+void
+glmc_rotate(mat4 m, float angle, vec3 axis);
+
+CGLM_EXPORT
+void
+glmc_decompose_scalev(mat4 m, vec3 s);
+
+CGLM_EXPORT
+void
+glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
+
+CGLM_EXPORT
+void
+glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
+
+#endif /* cglmc_affine_h */

include/call/cglmc-cam.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_cam_h
+#define cglmc_cam_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum(float left,
+             float right,
+             float bottom,
+             float top,
+             float nearVal,
+             float farVal,
+             mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho(float left,
+           float right,
+           float bottom,
+           float top,
+           float nearVal,
+           float farVal,
+           mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_perspective(float fovy,
+                 float aspect,
+                 float nearVal,
+                 float farVal,
+                 mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_lookat(vec3 eye,
+            vec3 center,
+            vec3 up,
+            mat4 dest);
+
+#endif /* cglmc_cam_h */

include/call/cglmc-euler.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef glmc_euler_h
+#define glmc_euler_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_euler_angles(mat4 m, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_euler(vec3 angles, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_zyx(vec3 angles,  mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_zxy(vec3 angles, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_xzy(vec3 angles, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_yzx(vec3 angles, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_yxz(vec3 angles, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
+
+#endif /* glmc_euler_h */

include/call/cglmc-io.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_io_h
+#define cglmc_io_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4_print(mat4   matrix,
+                FILE * __restrict ostream);
+
+CGLM_EXPORT
+void
+glmc_mat3_print(mat3 matrix,
+                FILE * __restrict ostream);
+
+CGLM_EXPORT
+void
+glmc_vec4_print(vec4 vec,
+                FILE * __restrict ostream);
+
+CGLM_EXPORT
+void
+glmc_vec3_print(vec3 vec,
+                FILE * __restrict ostream);
+
+CGLM_EXPORT
+void
+glmc_versor_print(versor vec,
+                  FILE * __restrict ostream);
+
+#endif /* cglmc_io_h */

include/call/cglmc-mat.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat_h
+#define cglmc_mat_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4_udup(mat4 mat, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_dup(mat4 mat, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_pick3(mat4 mat, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_pick3t(mat4 mat, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_ins3(mat3 mat, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_mulN(mat4 * __restrict matrices[], int len, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_transpose_to(mat4 m, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_transpose(mat4 m);
+
+CGLM_EXPORT
+void
+glmc_mat4_scale_p(mat4 m, float s);
+
+CGLM_EXPORT
+void
+glmc_mat4_scale(mat4 m, float s);
+
+CGLM_EXPORT
+float
+glmc_mat4_det(mat4 mat);
+
+CGLM_EXPORT
+void
+glmc_mat4_inv(mat4 mat, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_inv_precise(mat4 mat, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4_swap_col(mat4 mat, int col1, int col2);
+
+CGLM_EXPORT
+void
+glmc_mat4_swap_row(mat4 mat, int row1, int row2);
+
+#endif /* cglmc_mat_h */

include/call/cglmc-mat3.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat3_h
+#define cglmc_mat3_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat3_dup(mat3 mat, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3_transpose_to(mat3 m, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3_transpose(mat3 m);
+
+CGLM_EXPORT
+void
+glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3_scale(mat3 m, float s);
+
+CGLM_EXPORT
+float
+glmc_mat3_det(mat3 mat);
+
+CGLM_EXPORT
+void
+glmc_mat3_inv(mat3 mat, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3_swap_col(mat3 mat, int col1, int col2);
+
+CGLM_EXPORT
+void
+glmc_mat3_swap_row(mat3 mat, int row1, int row2);
+
+#endif /* cglmc_mat3_h */

include/call/cglmc-quat.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_quat_h
+#define cglmc_quat_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_quat_init(versor q,
+               float angle,
+               float x,
+               float y,
+               float z);
+
+CGLM_EXPORT
+float
+glmc_quat_norm(versor q);
+
+CGLM_EXPORT
+void
+glmc_quat_normalize(versor q);
+
+CGLM_EXPORT
+float
+glmc_quat_dot(versor q, versor r);
+
+CGLM_EXPORT
+void
+glmc_quat_mulv(versor q1, versor q2, versor dest);
+
+CGLM_EXPORT
+void
+glmc_quat_mat4(versor q, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_quat_slerp(versor q,
+                versor r,
+                float  t,
+                versor dest);
+
+#endif /* cglmc_quat_h */

include/call/cglmc-vec.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_vec_h
+#define cglm_vec_h
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_vec_dup(vec3 a, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_dup3(vec4 a, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_dup(vec4 v, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_vec_dot(vec3 a, vec3 b);
+
+CGLM_EXPORT
+float
+glmc_vec4_dot(vec4 a, vec4 b);
+
+CGLM_EXPORT
+void
+glmc_vec_cross(vec3 a, vec3 b, vec3 d);
+
+CGLM_EXPORT
+float
+glmc_vec_norm(vec3 vec);
+
+CGLM_EXPORT
+float
+glmc_vec4_norm(vec4 vec);
+
+CGLM_EXPORT
+void
+glmc_vec_normalize_to(vec3 vec, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize_to(vec4 vec, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec_normalize(vec3 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize(vec4 v);
+
+CGLM_EXPORT
+void
+glmc_vec_add(vec3 v1, vec3 v2, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec_scale(vec3 v, float s, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec_flipsign(vec3 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_flipsign(vec4 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_scale(vec4 v, float s, vec4 dest);
+
+#endif /* cglm_vec_h */

include/cglm-call.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_call_h
+#define cglm_call_h
+
+#include "cglm.h"
+#include "call/cglmc-vec.h"
+#include "call/cglmc-mat.h"
+#include "call/cglmc-mat3.h"
+#include "call/cglmc-affine.h"
+#include "call/cglmc-cam.h"
+#include "call/cglmc-quat.h"
+#include "call/cglmc-euler.h"
+#include "call/cglmc-io.h"
+
+#endif /* cglm_call_h */

include/cglm-common.h

@@ -14,8 +14,14 @@
 #include <math.h>
 
 #if defined(_WIN32)
+#  ifdef CGLM_DLL
+#    define CGLM_EXPORT __declspec(dllexport)
+#  else
+#    define CGLM_EXPORT __declspec(dllimport)
+#  endif
 #  define CGLM_INLINE __forceinline
 #else
+#  define CGLM_EXPORT __attribute__((visibility("default")))
 #  define CGLM_INLINE static inline __attribute((always_inline))
 #endif
 

makefile.am

@@ -0,0 +1,61 @@
+#******************************************************************************
+# Copyright (c), Recep Aslantas.                                              *
+#                                                                             *
+# MIT License (MIT), http://opensource.org/licenses/MIT                       *
+# Full license can be found in the LICENSE file                               *
+#                                                                             *
+#******************************************************************************
+
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CFLAGS = -Wall \
+            -std=gnu99 \
+            -O3 \
+            -Wstrict-aliasing=2 \
+            -fstrict-aliasing \
+            -Wpedantic
+
+lib_LTLIBRARIES = libcglm.la
+libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
+
+nobase_include_HEADERS = include/cglm.h \
+                         include/cglm-call.h \
+                         include/cglm-cam.h \
+                         include/cglm-io.h \
+                         include/cglm-mat3.h \
+                         include/cglm-types.h \
+                         include/cglm-common.h \
+                         include/cglm-affine.h \
+                         include/cglm-vec.h \
+                         include/cglm-euler.h \
+                         include/cglm-util.h \
+                         include/cglm-quat.h \
+                         include/cglm-mat.h \
+                         include/cglm-affine-mat.h \
+                         include/cglm-platform.h \
+                         include/cglm-mat-simd-avx.h \
+                         include/cglm-affine-mat-avx.h \
+                         include/cglm-opengl.h \
+                         include/cglm-quat-simd.h \
+                         include/cglm-affine-mat-sse2.h \
+                         include/cglm-mat3-simd-sse2.h \
+                         include/cglm-mat-simd-sse2.h \
+                         include/cglm-intrin.h \
+                         include/call/cglmc-euler.h \
+                         include/call/cglmc-quat.h \
+                         include/call/cglmc-cam.h \
+                         include/call/cglmc-io.h \
+                         include/call/cglmc-affine.h \
+                         include/call/cglmc-vec.h \
+                         include/call/cglmc-mat3.h \
+                         include/call/cglmc-mat.h
+
+libcglm_la_SOURCES=\
+    src/cglm-euler.c \
+    src/clgm-affine.c \
+    src/cglm-io.c \
+    src/cglm-quat.c \
+    src/cglm-cam.c \
+    src/cglm-vec.c \
+    src/cglm-mat3.c \
+    src/cglm-mat.c

src/cglm-cam.c

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum(float left,
+             float right,
+             float bottom,
+             float top,
+             float nearVal,
+             float farVal,
+             mat4 dest) {
+  glm_frustum(left,
+              right,
+              bottom,
+              top,
+              nearVal,
+              farVal,
+              dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho(float left,
+           float right,
+           float bottom,
+           float top,
+           float nearVal,
+           float farVal,
+           mat4 dest) {
+  glm_ortho(left,
+            right,
+            bottom,
+            top,
+            nearVal,
+            farVal,
+            dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective(float fovy,
+                 float aspect,
+                 float nearVal,
+                 float farVal,
+                 mat4 dest) {
+  glm_perspective(fovy,
+                  aspect,
+                  nearVal,
+                  farVal,
+                  dest);
+}
+
+CGLM_EXPORT
+void
+glmc_lookat(vec3 eye,
+            vec3 center,
+            vec3 up,
+            mat4 dest) {
+  glm_lookat(eye, center, up, dest);
+}

src/cglm-euler.c

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_euler_angles(mat4 m, vec3 dest) {
+  glm_euler_angles(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler(vec3 angles, mat4 dest) {
+  glm_euler(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_zyx(vec3 angles,  mat4 dest) {
+  glm_euler_zyx(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_zxy(vec3 angles, mat4 dest) {
+  glm_euler_zxy(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_xzy(vec3 angles, mat4 dest) {
+  glm_euler_xzy(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_yzx(vec3 angles, mat4 dest) {
+  glm_euler_yzx(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_yxz(vec3 angles, mat4 dest) {
+  glm_euler_yxz(angles, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest) {
+  glm_euler_by_order(angles, axis, dest);
+}

src/cglm-io.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4_print(mat4   matrix,
+                FILE * __restrict ostream) {
+  glm_mat4_print(matrix, ostream);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_print(mat3 matrix,
+                FILE * __restrict ostream) {
+  glm_mat3_print(matrix, ostream);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_print(vec4 vec,
+                FILE * __restrict ostream) {
+  glm_vec4_print(vec, ostream);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_print(vec3 vec,
+                FILE * __restrict ostream) {
+  glm_vec3_print(vec, ostream);
+}
+
+CGLM_EXPORT
+void
+glmc_versor_print(versor vec,
+                  FILE * __restrict ostream) {
+  glm_versor_print(vec, ostream);
+}

src/cglm-mat.c

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4_udup(mat4 mat, mat4 dest) {
+  glm_mat4_dup(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_dup(mat4 mat, mat4 dest) {
+  glm_mat4_dup(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_pick3(mat4 mat, mat3 dest) {
+  glm_mat4_pick3(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_pick3t(mat4 mat, mat3 dest) {
+  glm_mat4_pick3t(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_ins3(mat3 mat, mat4 dest) {
+  glm_mat4_ins3(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
+  glm_mat4_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_mulN(mat4 * __restrict matrices[], int len, mat4 dest) {
+  glm_mat4_mulN(matrices, len, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
+  glm_mat4_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_transpose_to(mat4 m, mat4 dest) {
+  glm_mat4_transpose_to(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_transpose(mat4 m) {
+  glm_mat4_transpose(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_scale_p(mat4 m, float s) {
+  glm_mat4_scale_p(m, s);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_scale(mat4 m, float s) {
+  glm_mat4_scale(m, s);
+}
+
+CGLM_EXPORT
+float
+glmc_mat4_det(mat4 mat) {
+  return glm_mat4_det(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_inv(mat4 mat, mat4 dest) {
+  glm_mat4_inv(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_inv_precise(mat4 mat, mat4 dest) {
+  glm_mat4_inv_precise(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_swap_col(mat4 mat, int col1, int col2) {
+  glm_mat4_swap_col(mat, col1, col2);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4_swap_row(mat4 mat, int row1, int row2) {
+  glm_mat4_swap_row(mat, row1, row2);
+}

src/cglm-mat3.c

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat3_dup(mat3 mat, mat3 dest) {
+  glm_mat3_dup(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
+  glm_mat3_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_transpose_to(mat3 m, mat3 dest) {
+  glm_mat3_transpose_to(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_transpose(mat3 m) {
+  glm_mat3_transpose(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
+  glm_mat3_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_scale(mat3 m, float s) {
+  glm_mat3_scale(m, s);
+}
+
+CGLM_EXPORT
+float
+glmc_mat3_det(mat3 mat) {
+  return glm_mat3_det(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_inv(mat3 mat, mat3 dest) {
+  glm_mat3_inv(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_swap_col(mat3 mat, int col1, int col2) {
+  glm_mat3_swap_col(mat, col1, col2);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3_swap_row(mat3 mat, int row1, int row2) {
+  glm_mat3_swap_row(mat, row1, row2);
+}

src/cglm-quat.c

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_quat_init(versor q,
+               float angle,
+               float x,
+               float y,
+               float z) {
+  glm_quat_init(q, angle, x, y, z);
+}
+
+CGLM_EXPORT
+float
+glmc_quat_norm(versor q) {
+  return glm_quat_norm(q);
+}
+
+CGLM_EXPORT
+void
+glmc_quat_normalize(versor q) {
+  glm_quat_normalize(q);
+}
+
+CGLM_EXPORT
+float
+glmc_quat_dot(versor q, versor r) {
+  return glm_quat_dot(q, r);
+}
+
+CGLM_EXPORT
+void
+glmc_quat_mulv(versor q1, versor q2, versor dest) {
+  glm_quat_mulv(q1, q2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_quat_mat4(versor q, mat4 dest) {
+  glm_quat_mat4(q, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_quat_slerp(versor q,
+                versor r,
+                float  t,
+                versor dest) {
+  glm_quat_slerp(q, r, t, dest);
+}

src/cglm-vec.c

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_vec_dup(vec3 a, vec3 dest) {
+  glm_vec_dup(a, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_dup3(vec4 a, vec3 dest) {
+  glm_vec4_dup3(a, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_dup(vec4 v, vec4 dest) {
+  glm_vec4_dup(v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec_dot(vec3 a, vec3 b) {
+  return glm_vec_dot(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_dot(vec4 a, vec4 b) {
+  return glm_vec4_dot(a, b);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_cross(vec3 a, vec3 b, vec3 d) {
+  glm_vec_cross(a, b, d);
+}
+
+CGLM_EXPORT
+float
+glmc_vec_norm(vec3 vec) {
+  return glm_vec_norm(vec);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_norm(vec4 vec) {
+  return glm_vec4_norm(vec);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_normalize_to(vec3 vec, vec3 dest) {
+  glm_vec_normalize_to(vec, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize_to(vec4 vec, vec4 dest) {
+  glm_vec4_normalize_to(vec, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_normalize(vec3 v) {
+  glm_vec_normalize(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize(vec4 v) {
+  glm_vec4_normalize(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_add(vec3 v1, vec3 v2, vec3 dest) {
+  glm_vec_add(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_add(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
+  glm_vec_sub(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_sub(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_scale(vec3 v, float s, vec3 dest) {
+  glm_vec_scale(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_flipsign(vec3 v) {
+  glm_vec_flipsign(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_flipsign(vec4 v) {
+  glm_vec4_flipsign(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_scale(vec4 v, float s, vec4 dest) {
+  glm_vec4_scale(v, s, dest);
+}

src/clgm-affine.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm.h"
+
+CGLM_EXPORT
+void
+glmc_translate_to(mat4 m, vec3 v, mat4 dest) {
+  glm_translate_to(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_translate(mat4 m, vec3 v) {
+  glm_translate(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_translate_x(mat4 m, float to) {
+  glm_translate_x(m, to);
+}
+
+CGLM_EXPORT
+void
+glmc_translate_y(mat4 m, float to) {
+  glm_translate_y(m, to);
+}
+
+CGLM_EXPORT
+void
+glmc_translate_z(mat4 m, float to) {
+  glm_translate_z(m, to);
+}
+
+CGLM_EXPORT
+void
+glmc_scale_to(mat4 m, vec3 v, mat4 dest) {
+  glm_scale_to(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_scale(mat4 m, vec3 v) {
+  glm_scale(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_scale1(mat4 m, float s) {
+  glm_scale1(m, s);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_x(mat4 m, float rad, mat4 dest) {
+  glm_rotate_x(m, rad, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_y(mat4 m, float rad, mat4 dest) {
+  glm_rotate_y(m, rad, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_z(mat4 m, float rad, mat4 dest) {
+  glm_rotate_z(m, rad, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_ndc_make(mat4 m, float angle, vec3 axis_ndc) {
+  glm_rotate_ndc_make(m, angle, axis_ndc);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_make(mat4 m, float angle, vec3 axis) {
+  glm_rotate_make(m, angle, axis);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate_ndc(mat4 m, float angle, vec3 axis_ndc) {
+  glm_rotate_ndc(m, angle, axis_ndc);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate(mat4 m, float angle, vec3 axis) {
+  glm_rotate(m, angle, axis);
+}
+
+CGLM_EXPORT
+void
+glmc_decompose_scalev(mat4 m, vec3 s) {
+  glm_decompose_scalev(m, s);
+}
+
+CGLM_EXPORT
+void
+glmc_decompose_rs(mat4 m, mat4 r, vec3 s) {
+  glm_decompose_rs(m, r, s);
+}
+
+CGLM_EXPORT
+void
+glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
+  glm_decompose(m, t, r, s);
+}