- separating struct types into types-struct.h

- vec3s implementation
- fix style issues

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

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 */

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 */

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;

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;

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 */

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)    */

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 */

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);
 

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);
 }