From 1aa54dc1109ea663b95984417baa0f4a3b851c9d Mon Sep 17 00:00:00 2001
From: acoto87 <acoto87@gmail.com>
Date: Mon, 8 Apr 2019 21:06:01 -0500
Subject: [PATCH] - separating struct types into `types-struct.h` - vec3s
 implementation - fix style issues

---
 include/cglm/cglms.h            |   2 +
 include/cglm/structs/vec3-ext.h | 100 ++++++++
 include/cglm/structs/vec3.h     | 398 ++++++++++++++++++++++++++++++++
 include/cglm/structs/vec4-ext.h |  48 ++--
 include/cglm/structs/vec4.h     |  96 +++-----
 include/cglm/types-struct.h     |  36 +++
 include/cglm/types.h            |  25 --
 test/src/test_common.c          |  14 ++
 test/src/test_common.h          |   6 +
 test/src/test_vec3.c            |   9 +
 10 files changed, 617 insertions(+), 117 deletions(-)
 create mode 100644 include/cglm/structs/vec3-ext.h
 create mode 100644 include/cglm/structs/vec3.h
 create mode 100644 include/cglm/types-struct.h

diff --git a/include/cglm/cglms.h b/include/cglm/cglms.h
index 4dd471f..9f00dc8 100644
--- a/include/cglm/cglms.h
+++ b/include/cglm/cglms.h
@@ -12,6 +12,8 @@ extern "C" {
 #endif
 
 #include "cglm.h"
+#include "types-struct.h"
+#include "structs/vec3.h"
 #include "structs/vec4.h"
 
 #ifdef __cplusplus
diff --git a/include/cglm/structs/vec3-ext.h b/include/cglm/structs/vec3-ext.h
new file mode 100644
index 0000000..0449b3d
--- /dev/null
+++ b/include/cglm/structs/vec3-ext.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_vec3s_ext_h
+#define cglm_vec3s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3-ext.h"
+
+CGLM_INLINE
+vec3s
+glms_vec3_broadcast(float val) {
+  vec3s r;
+  glm_vec3_broadcast(val, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+bool
+glms_vec3_eq(vec3s v, float val) {
+  return glm_vec3_eq(v.raw, val);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_eq_eps(vec3s v, float val) {
+  return glm_vec3_eq_eps(v.raw, val);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_eq_all(vec3s v) {
+  return glm_vec3_eq_all(v.raw);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_eqv(vec3s a, vec3s b) {
+  return glm_vec3_eqv(a.raw, b.raw);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_eqv_eps(vec3s a, vec3s b) {
+  return glm_vec3_eqv_eps(a.raw, b.raw);
+}
+
+CGLM_INLINE
+float
+glms_vec3_max(vec3s v) {
+  return glm_vec3_max(v.raw);
+}
+
+CGLM_INLINE
+float
+glms_vec3_min(vec3s v) {
+  return glm_vec3_min(v.raw);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_isnan(vec3s v) {
+  return glm_vec3_isnan(v.raw);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_isinf(vec3s v) {
+  return glm_vec3_isinf(v.raw);
+}
+
+CGLM_INLINE
+bool
+glms_vec3_isvalid(vec3s v) {
+  return glm_vec3_isvalid(v.raw);
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_sign(vec3s v) {
+  vec3s r;
+  glm_vec3_sign(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_sqrt(vec3s v) {
+  vec3s r;
+  glm_vec3_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglm_vec3s_ext_h */
diff --git a/include/cglm/structs/vec3.h b/include/cglm/structs/vec3.h
new file mode 100644
index 0000000..ed77c4a
--- /dev/null
+++ b/include/cglm/structs/vec3.h
@@ -0,0 +1,398 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_vec3s_h
+#define cglm_vec3s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3.h"
+#include "vec3-ext.h"
+
+#define GLMS_VEC3_ONE_INIT   {1.0f, 1.0f, 1.0f}
+#define GLMS_VEC3_ZERO_INIT  {0.0f, 0.0f, 0.0f}
+
+#define GLMS_VEC3_ONE  ((vec3s)GLMS_VEC3_ONE_INIT)
+#define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT)
+
+#define GLMS_YUP  ((vec3s){0.0f, 1.0f, 0.0f})
+#define GLMS_ZUP  ((vec3s){0.0f, 0.0f, 1.0f})
+#define GLMS_XUP  ((vec3s){1.0f, 0.0f, 0.0f})
+
+CGLM_INLINE
+vec3s
+glms_vec3(vec4s v4) {
+  vec3s r;
+  glm_vec3(v4.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_copy(vec3s v) {
+  vec3s r;
+  glm_vec3_copy(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_zero() {
+  vec3s r;
+  glm_vec3_zero(r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_one() {
+  vec3s r;
+  glm_vec3_one(r.raw);
+  return r;
+}
+
+CGLM_INLINE
+float
+glms_vec3_dot(vec3s a, vec3s b) {
+  return glm_vec3_dot(a.raw, b.raw);
+}
+
+CGLM_INLINE
+float
+glms_vec3_norm2(vec3s v) {
+  glm_vec3_norm2(v.raw);
+}
+
+CGLM_INLINE
+float
+glms_vec3_norm(vec3s v) {
+  glm_vec3_norm(v.raw);
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_add(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_adds(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_adds(a.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_sub(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_subs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_subs(a.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_mul(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_scale(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_scale(v.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_scale_as(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_div(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_divs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_divs(a.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_addadd(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_addadd(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_subadd(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_subadd(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_muladd(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_muladd(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_muladds(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_muladds(a.raw, s, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_maxadd(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_maxadd(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_minadd(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_minadd(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_flipsign(vec3s v) {
+  glm_vec3_flipsign(v.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_flipsign_to(vec3s v) {
+  vec3s r;
+  glm_vec3_flipsign_to(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_negate_to(vec3s v) {
+  vec3s r;
+  glm_vec3_negate_to(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_negate(vec3s v) {
+  glm_vec3_negate(v.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_inv(vec3s v) {
+  glm_vec3_inv(v.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_inv_to(vec3s v) {
+  vec3s r;
+  glm_vec3_inv_to(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_normalize(vec3s v) {
+  glm_vec3_normalize(v.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_normalize_to(vec3s v) {
+  vec3s r;
+  glm_vec3_normalize_to(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_crossn(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_crossn(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+float
+glms_vec3_distance(vec3s a, vec3s b) {
+  return glm_vec3_distance(a.raw, b.raw);
+}
+
+CGLM_INLINE
+float
+glms_vec3_angle(vec3s a, vec3s b) {
+  return glm_vec3_angle(a.raw, b.raw);
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
+  glm_vec3_rotate(v.raw, angle, axis.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m4(mat4 m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m4(m, v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m3(mat3 m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m3(m, v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_proj(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_proj(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_center(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_center(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+float
+glms_vec3_distance2(vec3s a, vec3s b) {
+  return glm_vec3_distance2(a.raw, b.raw);
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_maxv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_minv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_ortho(vec3s v) {
+  vec3s r;
+  glm_vec3_ortho(v.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
+  glm_vec3_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_vec3_lerp(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+vec3s
+glms_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+CGLM_INLINE
+float
+glms_dot(vec3s a, vec3s b) {
+  return glm_dot(a.raw, b.raw);
+}
+
+CGLM_INLINE
+vec3s
+glms_normalize(vec3s v) {
+  glm_normalize(v.raw);
+  return v;
+}
+
+CGLM_INLINE
+vec3s
+glms_normalize_to(vec3s v) {
+  vec3s r;
+  glm_normalize_to(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglm_vec3s_h */
diff --git a/include/cglm/structs/vec4-ext.h b/include/cglm/structs/vec4-ext.h
index ea84e82..4fbb2d3 100644
--- a/include/cglm/structs/vec4-ext.h
+++ b/include/cglm/structs/vec4-ext.h
@@ -8,16 +8,14 @@
 #ifndef cglm_vec4s_ext_h
 #define cglm_vec4s_ext_h
 
-#include "common.h"
-#include "vec3-ext.h"
-#include <stdbool.h>
-#include <math.h>
-#include <float.h>
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4-ext.h"
 
 CGLM_INLINE
 vec4s
-glms_vec4_broadcast(float val, vec4 d)
-{
+glms_vec4_broadcast(float val) {
   vec4s r;
   glm_vec4_broadcast(val, r.raw);
   return r;
@@ -25,78 +23,67 @@ glms_vec4_broadcast(float val, vec4 d)
 
 CGLM_INLINE
 bool
-glms_vec4_eq(vec4s v, float val)
-{
+glms_vec4_eq(vec4s v, float val) {
   return glm_vec4_eq(v.raw, val);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_eq_eps(vec4 v, float val)
-{
+glms_vec4_eq_eps(vec4s v, float val) {
   return glm_vec4_eq_eps(v.raw, val);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_eq_all(vec4s v)
-{
+glms_vec4_eq_all(vec4s v) {
   return glm_vec4_eq_all(v.raw);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_eqv(vec4s a, vec4s b)
-{
+glms_vec4_eqv(vec4s a, vec4s b) {
   return glm_vec4_eqv(a.raw, b.raw);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_eqv_eps(vec4s a, vec4s b)
-{
+glms_vec4_eqv_eps(vec4s a, vec4s b) {
   return glm_vec4_eqv_eps(a.raw, b.raw);
 }
 
 CGLM_INLINE
 float
-glms_vec4_max(vec4s v)
-{
+glms_vec4_max(vec4s v) {
   return glm_vec4_max(v.raw);
 }
 
 CGLM_INLINE
 float
-glms_vec4_min(vec4s v)
-{
+glms_vec4_min(vec4s v) {
   return glm_vec4_min(v.raw);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_isnan(vec4s v)
-{
+glms_vec4_isnan(vec4s v) {
   return glm_vec4_isnan(v.raw);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_isinf(vec4s v)
-{
+glms_vec4_isinf(vec4s v) {
   return glm_vec4_isinf(v.raw);
 }
 
 CGLM_INLINE
 bool
-glms_vec4_isvalid(vec4s v)
-{
+glms_vec4_isvalid(vec4s v) {
   return glm_vec4_isvalid(v.raw);
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_sign(vec4s v)
-{
+glms_vec4_sign(vec4s v) {
   vec4s r;
   glm_vec4_sign(v.raw, r.raw);
   return r;
@@ -104,8 +91,7 @@ glms_vec4_sign(vec4s v)
 
 CGLM_INLINE
 vec4s
-glms_vec4_sqrt(vec4s v)
-{
+glms_vec4_sqrt(vec4s v) {
   vec4s r;
   glm_vec4_sqrt(v.raw, r.raw);
   return r;
diff --git a/include/cglm/structs/vec4.h b/include/cglm/structs/vec4.h
index b68bb33..c0a79c3 100644
--- a/include/cglm/structs/vec4.h
+++ b/include/cglm/structs/vec4.h
@@ -12,7 +12,11 @@
 extern "C" {
 #endif
 
-#include "../cglm.h"
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4.h"
+#include "vec4-ext.h"
 
 #define GLMS_VEC4_ONE_INIT   {1.0f, 1.0f, 1.0f, 1.0f}
 #define GLMS_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
@@ -24,8 +28,7 @@ extern "C" {
 
 CGLM_INLINE
 vec4s
-glms_vec4(vec3s v3, float last)
-{
+glms_vec4(vec3s v3, float last) {
   vec4s r;
   glm_vec4(v3.raw, last, r.raw);
   return r;
@@ -33,8 +36,7 @@ glms_vec4(vec3s v3, float last)
 
 CGLM_INLINE
 vec3s
-glms_vec4_copy3(vec4s v)
-{
+glms_vec4_copy3(vec4s v) {
   vec3s r;
   glm_vec4_copy3(v.raw, r.raw);
   return r;
@@ -42,8 +44,7 @@ glms_vec4_copy3(vec4s v)
 
 CGLM_INLINE
 vec4s
-glms_vec4_copy(vec4s v)
-{
+glms_vec4_copy(vec4s v) {
   vec4s r;
   glm_vec4_copy(v.raw, r.raw);
   return r;
@@ -51,8 +52,7 @@ glms_vec4_copy(vec4s v)
 
 CGLM_INLINE
 vec4s
-glms_vec4_ucopy(vec4s v)
-{
+glms_vec4_ucopy(vec4s v) {
   vec4s r;
   glm_vec4_ucopy(v.raw, r.raw);
   return r;
@@ -61,29 +61,25 @@ glms_vec4_ucopy(vec4s v)
 
 CGLM_INLINE
 float
-glms_vec4_dot(vec4s a, vec4s b)
-{
+glms_vec4_dot(vec4s a, vec4s b) {
   return glm_vec4_dot(a.raw, b.raw);
 }
 
 CGLM_INLINE
 float
-glms_vec4_norm2(vec4s v)
-{
+glms_vec4_norm2(vec4s v) {
   return glm_vec4_norm2(v.raw);
 }
 
 CGLM_INLINE
 float
-glms_vec4_norm(vec4s v)
-{
+glms_vec4_norm(vec4s v) {
   return glm_vec4_norm(v.raw);
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_add(vec4s a, vec4s b)
-{
+glms_vec4_add(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_add(a.raw, b.raw, r.raw);
   return r;
@@ -91,8 +87,7 @@ glms_vec4_add(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_adds(vec4s v, float s)
-{
+glms_vec4_adds(vec4s v, float s) {
   vec4s r;
   glm_vec4_adds(v.raw, s, r.raw);
   return r;
@@ -100,8 +95,7 @@ glms_vec4_adds(vec4s v, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_sub(vec4s a, vec4s b)
-{
+glms_vec4_sub(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_sub(a.raw, b.raw, r.raw);
   return r;
@@ -109,8 +103,7 @@ glms_vec4_sub(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_subs(vec4s v, float s)
-{
+glms_vec4_subs(vec4s v, float s) {
   vec4s r;
   glm_vec4_subs(v.raw, s, r.raw);
   return r;
@@ -118,8 +111,7 @@ glms_vec4_subs(vec4s v, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_mul(vec4s a, vec4s b)
-{
+glms_vec4_mul(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_mul(a.raw, b.raw, r.raw);
   return r;
@@ -127,8 +119,7 @@ glms_vec4_mul(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_scale(vec4s v, float s)
-{
+glms_vec4_scale(vec4s v, float s) {
   vec4s r;
   glm_vec4_scale(v.raw, s, r.raw);
   return r;
@@ -136,8 +127,7 @@ glms_vec4_scale(vec4s v, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_scale_as(vec4s v, float s)
-{
+glms_vec4_scale_as(vec4s v, float s) {
   vec4s r;
   glm_vec4_scale_as(v.raw, s, r.raw);
   return r;
@@ -145,8 +135,7 @@ glms_vec4_scale_as(vec4s v, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_div(vec4s a, vec4s b)
-{
+glms_vec4_div(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_div(a.raw, b.raw, r.raw);
   return r;
@@ -154,8 +143,7 @@ glms_vec4_div(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_divs(vec4s v, float s)
-{
+glms_vec4_divs(vec4s v, float s) {
   vec4s r;
   glm_vec4_divs(v.raw, s, r.raw);
   return r;
@@ -163,8 +151,7 @@ glms_vec4_divs(vec4s v, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_addadd(vec4s a, vec4s b)
-{
+glms_vec4_addadd(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_addadd(a.raw, b.raw, r.raw);
   return r;
@@ -172,8 +159,7 @@ glms_vec4_addadd(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_subadd(vec4s a, vec4s b)
-{
+glms_vec4_subadd(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_subadd(a.raw, b.raw, r.raw);
   return r;
@@ -181,8 +167,7 @@ glms_vec4_subadd(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_muladd(vec4s a, vec4s b)
-{
+glms_vec4_muladd(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_muladd(a.raw, b.raw, r.raw);
   return r;
@@ -190,8 +175,7 @@ glms_vec4_muladd(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_muladds(vec4s a, float s)
-{
+glms_vec4_muladds(vec4s a, float s) {
   vec4s r;
   glm_vec4_muladds(a.raw, s, r.raw);
   return r;
@@ -199,8 +183,7 @@ glms_vec4_muladds(vec4s a, float s)
 
 CGLM_INLINE
 vec4s
-glms_vec4_maxadd(vec4s a, vec4s b)
-{
+glms_vec4_maxadd(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_maxadd(a.raw, b.raw, r.raw);
   return r;
@@ -208,8 +191,7 @@ glms_vec4_maxadd(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_minadd(vec4s a, vec4s b)
-{
+glms_vec4_minadd(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_minadd(a.raw, b.raw, r.raw);
   return r;
@@ -217,39 +199,34 @@ glms_vec4_minadd(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_negate(vec4s v)
-{
+glms_vec4_negate(vec4s v) {
   glm_vec4_negate(v.raw);
   return v;
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_inv(vec4s v)
-{
+glms_vec4_inv(vec4s v) {
   glm_vec4_inv(v.raw);
   return v;
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_normalize(vec4s v)
-{
+glms_vec4_normalize(vec4s v) {
   glm_vec4_normalize(v.raw);
   return v;
 }
 
 CGLM_INLINE
 float
-glms_vec4_distance(vec4s a, vec4s b)
-{
+glms_vec4_distance(vec4s a, vec4s b) {
   return glm_vec4_distance(a.raw, b.raw);
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_maxv(vec4s a, vec4s b)
-{
+glms_vec4_maxv(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_maxv(a.raw, b.raw, r.raw);
   return r;
@@ -257,8 +234,7 @@ glms_vec4_maxv(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_minv(vec4s a, vec4s b)
-{
+glms_vec4_minv(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_minv(a.raw, b.raw, r.raw);
   return r;
@@ -266,16 +242,14 @@ glms_vec4_minv(vec4s a, vec4s b)
 
 CGLM_INLINE
 vec4s
-glms_vec4_clamp(vec4s v, float minVal, float maxVal)
-{
+glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
   glm_vec4_clamp(v.raw, minVal, maxVal);
   return v;
 }
 
 CGLM_INLINE
 vec4s
-glms_vec4_lerp(vec4s from, vec4s to, float t)
-{
+glms_vec4_lerp(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_lerp(from.raw, to.raw, t, r.raw);
   return r;
diff --git a/include/cglm/types-struct.h b/include/cglm/types-struct.h
new file mode 100644
index 0000000..27e04fe
--- /dev/null
+++ b/include/cglm/types-struct.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_types_struct_h
+#define cglm_types_struct_h
+
+#include "types.h"
+
+typedef union CGLM_ALIGN_IF(16) vec3s {
+#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+    float z;
+  };
+#endif
+  vec3 raw;
+} vec3s;
+
+typedef union CGLM_ALIGN_IF(16) vec4s {
+#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+    float z;
+    float w;
+  };
+#endif
+  vec4 raw;
+} vec4s;
+
+#endif /* cglm_types_struct_h */
diff --git a/include/cglm/types.h b/include/cglm/types.h
index 69c2885..1190b73 100644
--- a/include/cglm/types.h
+++ b/include/cglm/types.h
@@ -32,7 +32,6 @@
 #  define CGLM_ALIGN_MAT CGLM_ALIGN(16)
 #endif
 
-// array types
 typedef float                   vec2[2];
 typedef float                   vec3[3];
 typedef int                    ivec3[3];
@@ -46,30 +45,6 @@ typedef CGLM_ALIGN_IF(32) vec4  mat4[4];
 typedef CGLM_ALIGN_IF(16) vec4  mat4[4];
 #endif
 
-// struct types
-typedef union CGLM_ALIGN_IF(16) vec3s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
-  struct {
-    float x;
-    float y;
-    float z;
-  };
-#endif
-  vec3 raw;
-} vec3s;
-
-typedef union CGLM_ALIGN_IF(16) vec4s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
-  struct {
-    float x;
-    float y;
-    float z;
-    float w;
-  };
-#endif
-  vec4 raw;
-} vec4s;
-
 #define GLM_E         2.71828182845904523536028747135266250   /* e           */
 #define GLM_LOG2E     1.44269504088896340735992468100189214   /* log2(e)     */
 #define GLM_LOG10E    0.434294481903251827651128918916605082  /* log10(e)    */
diff --git a/test/src/test_common.c b/test/src/test_common.c
index 94331f4..f835235 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -47,6 +47,14 @@ test_rand_vec3(vec3 dest) {
   dest[2] = drand48();
 }
 
+vec3s
+test_rand_vec3s()
+{
+  vec3s r;
+  test_rand_vec3(r.raw);
+  return r;
+}
+
 void
 test_rand_vec4(vec4 dest) {
   srand((unsigned int)time(NULL));
@@ -127,6 +135,12 @@ test_assert_vec3_eq(vec3 v1, vec3 v2) {
   assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
 }
 
+void
+test_assert_vec3s_eq(vec3s v1, vec3s v2)
+{
+  test_assert_vec3_eq(v1.raw, v2.raw);
+}
+
 void
 test_assert_vec4_eq(vec4 v1, vec4 v2) {
   assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
diff --git a/test/src/test_common.h b/test/src/test_common.h
index c6a2dc4..51d1826 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -44,6 +44,9 @@ test_assert_mat3_eq(mat3 m1, mat3 m2);
 void
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 
+void
+test_assert_vec3s_eq(vec3s v1, vec3s v2);
+
 void
 test_assert_vec4_eq(vec4 v1, vec4 v2);
 
@@ -59,6 +62,9 @@ test_assert_quat_eq_abs(versor v1, versor v2);
 void
 test_rand_vec3(vec3 dest);
 
+vec3s
+test_rand_vec3s();
+
 void
 test_rand_vec4(vec4 dest);
 
diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c
index 6cfc593..4f1f2d1 100644
--- a/test/src/test_vec3.c
+++ b/test/src/test_vec3.c
@@ -12,6 +12,7 @@ test_vec3(void **state) {
   mat3 rot1m3;
   mat4 rot1;
   vec3 v, v1, v2;
+  vec3s vs1, vs2, vs3, vs4;
 
   /* test zero */
   glm_vec3_zero(v);
@@ -75,4 +76,12 @@ test_vec3(void **state) {
 
   test_assert_vec3_eq(v1, v2);
   test_assert_vec3_eq(v1, GLM_ZUP);
+
+  /* structs */
+  vs1 = test_rand_vec3s();
+  vs2 = test_rand_vec3s();
+
+  vs3 = glms_vec3_add(vs1, vs2);
+  vs4 = glms_vec3_maxv(vs1, vs3);
+  test_assert_vec3s_eq(vs3, vs4);
 }