Implement struct API for ivec2, ivec3, and ivec4

Makefile.am

@@ -198,10 +198,13 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/affine2d.h \
                       include/cglm/struct/vec2.h \
                       include/cglm/struct/vec2-ext.h \
+                      include/cglm/struct/ivec2.h \
                       include/cglm/struct/vec3.h \
                       include/cglm/struct/vec3-ext.h \
+                      include/cglm/struct/ivec3.h \
                       include/cglm/struct/vec4.h \
                       include/cglm/struct/vec4-ext.h \
+                      include/cglm/struct/ivec4.h \
                       include/cglm/struct/io.h \
                       include/cglm/struct/cam.h \
                       include/cglm/struct/quat.h \

include/cglm/struct.h

@@ -16,6 +16,9 @@ extern "C" {
 #include "struct/vec2.h"
 #include "struct/vec3.h"
 #include "struct/vec4.h"
+#include "struct/ivec2.h"
+#include "struct/ivec3.h"
+#include "struct/ivec4.h"
 #include "struct/mat2.h"
 #include "struct/mat2x3.h"
 #include "struct/mat2x4.h"

include/cglm/struct/io.h

@@ -7,14 +7,16 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_mat4_print(mat4 matrix, FILE *ostream);
+   CGLM_INLINE void glms_mat4_print(mat4s matrix, FILE *ostream);
-   CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
+   CGLM_INLINE void glms_mat3_print(mat3s matrix, FILE *ostream);
-   CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
+   CGLM_INLINE void glms_vec4_print(vec4s vec, FILE *ostream);
-   CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
+   CGLM_INLINE void glms_ivec4_print(ivec3s vec, FILE *ostream);
-   CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
+   CGLM_INLINE void glms_vec3_print(vec3s vec, FILE *ostream);
-   CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
+   CGLM_INLINE void glms_ivec3_print(ivec3s vec, FILE *ostream);
-
+   CGLM_INLINE void glms_vec2_print(vec2s vec, FILE *ostream);
-   CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
+   CGLM_INLINE void glms_ivec2_print(ivec3s vec, FILE *ostream);
+   CGLM_INLINE void glms_versor_print(versor vec, FILE *ostream);
+   CGLM_INLINE void glms_aabb_print(vec3s bbox[2], const char *tag, FILE *ostream);
  */
 
 #ifndef cglms_ios_h
@@ -49,6 +51,13 @@ glms_vec4_print(vec4s             vec,
   glm_vec4_print(vec.raw, ostream);
 }
 
+CGLM_INLINE
+void
+glms_ivec4_print(ivec4s            vec,
+                 FILE * __restrict ostream) {
+  glm_ivec4_print(vec.raw, ostream);
+}
+
 CGLM_INLINE
 void
 glms_vec3_print(vec3s             vec,
@@ -63,6 +72,20 @@ glms_ivec3_print(ivec3s            vec,
   glm_ivec3_print(vec.raw, ostream);
 }
 
+CGLM_INLINE
+void
+glms_vec2_print(vec2s             vec,
+                FILE * __restrict ostream) {
+  glm_vec2_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_ivec2_print(ivec2s            vec,
+                 FILE * __restrict ostream) {
+  glm_ivec2_print(vec.raw, ostream);
+}
+
 CGLM_INLINE
 void
 glms_versor_print(versors           vec,

include/cglm/struct/ivec2.h

@@ -0,0 +1,708 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+  GLMS_IVEC2_ONE_INIT
+  GLMS_IVEC2_ZERO_INIT
+  GLMS_IVEC2_ONE
+  GLMS_IVEC2_ZERO
+
+ Functions:
+  CGLM_INLINE ivec2s glms_ivec2(int * __restrict v)
+  CGLM_INLINE void glms_ivec2_pack(ivec2s dst[], ivec2s src[], size_t len)
+  CGLM_INLINE void glms_ivec2_unpack(ivec2 dst[], ivec2 src[], size_t len)
+  CGLM_INLINE ivec2s glms_ivec2_zero(ivec2s v)
+  CGLM_INLINE ivec2s glms_ivec2_one(ivec2s v)
+  CGLM_INLINE int glms_ivec2_dot(ivec2s a, ivec2s b)
+  CGLM_INLINE int glms_ivec2_cross(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_add(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_adds(ivec2s v, int s)
+  CGLM_INLINE ivec2s glms_ivec2_sub(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_subs(ivec2s v, int s)
+  CGLM_INLINE ivec2s glms_ivec2_mul(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_scale(ivec2s v, int s)
+  CGLM_INLINE ivec2s glms_ivec2_div(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_divs(ivec2s v, int s)
+  CGLM_INLINE ivec2s glms_ivec2_mod(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_addadd(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_addadds(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_subadd(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_subadds(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_muladd(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_muladds(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_maxadd(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_minadd(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_subsub(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_subsubs(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_addsub(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_addsubs(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_mulsub(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_mulsubs(ivec2s a, int s)
+  CGLM_INLINE ivec2s glms_ivec2_maxsub(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_minsub(ivec2s a, ivec2s b)
+  CGLM_INLINE int glms_ivec2_distance2(ivec2s a, ivec2s b)
+  CGLM_INLINE float glms_ivec2_distance(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_fill(int val)
+  CGLM_INLINE bool glms_ivec2_eq(ivec2s v, int val);
+  CGLM_INLINE bool glms_ivec2_eqv(ivec2s a, ivec2s b);
+  CGLM_INLINE ivec2s glms_ivec2_maxv(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_minv(ivec2s a, ivec2s b)
+  CGLM_INLINE ivec2s glms_ivec2_clamp(ivec2s v, int minVal, int maxVal)
+  CGLM_INLINE ivec2s glms_ivec2_abs(ivec2s v)
+ */
+
+#ifndef cglms_ivec2_h
+#define cglms_ivec2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../ivec2.h"
+
+#define glms_ivec2_(NAME) CGLM_STRUCTAPI(ivec2, NAME)
+
+#define GLMS_IVEC2_ONE_INIT   {GLM_IVEC2_ONE_INIT}
+#define GLMS_IVEC2_ZERO_INIT  {GLM_IVEC2_ZERO_INIT}
+
+#define GLMS_IVEC2_ONE  ((ivec2s)GLMS_IVEC2_ONE_INIT)
+#define GLMS_IVEC2_ZERO ((ivec2s)GLMS_IVEC2_ZERO_INIT)
+
+/*!
+ * @brief init ivec2 using ivec3 or ivec4
+ *
+ * @param[in]  v    vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2(int * __restrict v) {
+  ivec2s r;
+  glm_ivec2(v, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of ivec2 into an array of ivec2s
+ *
+ * @param[out] dst array of ivec2s
+ * @param[in]  src array of ivec2
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec2_(pack)(ivec2s dst[], ivec2 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec2_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of ivec2s into an array of ivec2
+ *
+ * @param[out] dst array of ivec2
+ * @param[in]  src array of ivec2s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec2_(unpack)(ivec2 dst[], ivec2s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec2_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec2s 
+glms_ivec2_(zero)(void) {
+  ivec2s r;
+  glm_ivec2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(one)(void) {
+  ivec2s r;
+  glm_ivec2_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief ivec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+int
+glms_ivec2_(dot)(ivec2s a, ivec2s b) {
+  return glm_ivec2_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief ivec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+int
+glms_ivec2_(cross)(ivec2s a, ivec2s b) {
+  return glm_ivec2_cross(a.raw, b.raw);
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(add)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(adds)(ivec2s v, int s) {
+  ivec2s r;
+  glm_ivec2_adds(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(sub)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(subs)(ivec2s v, int s) {
+  ivec2s r;
+  glm_ivec2_subs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(mul)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(scale)(ivec2s v, int s) {
+  ivec2s r;
+  glm_ivec2_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1])
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(div)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s)
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(divs)(ivec2s v, int s) {
+  ivec2s r;
+  glm_ivec2_divs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief mod vector with another component-wise modulo: d = a % b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]%b[0], a[1]%b[1])
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(mod)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_mod(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add vector [a] with vector [b] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(addadd)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] onto vector [a] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a + s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(addadds)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_addadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a - b)  
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(subadd)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(subadds)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_subadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(muladd)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(muladds)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add maximum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(maxadd)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add minimum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(minadd)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= (a - b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(subsub)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_subsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(subsubs)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_subsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(addsub)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_addsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] to vector [a] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(addsubs)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_addsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] and vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(mulsub)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_mulsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(mulsubs)(ivec2s a, int s, ivec2s dest) {
+  glm_ivec2_mulsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract maximum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(maxsub)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_maxsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract minimum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec2s 
+glms_ivec2_(minsub)(ivec2s a, ivec2s b, ivec2s dest) {
+  glm_ivec2_minsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glms_ivec2_(distance2)(ivec2s a, ivec2s b) {
+  return glm_ivec2_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glms_ivec2_(distance)(ivec2s a, ivec2s b) {
+  return glm_ivec2_distance(a.raw, b.raw);
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val value
+ * @returns        dest
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(fill)(int val) {
+  ivec2s r;
+  glm_ivec2_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_ivec2_(eq)(ivec2s v, int val) {
+  return glm_ivec2_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to another
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_ivec2_(eqv)(ivec2s a, ivec2s b) {
+  return glm_ivec2_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(maxv)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(minv)(ivec2s a, ivec2s b) {
+  ivec2s r;
+  glm_ivec2_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in]      v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ * @returns               clamped vector
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(clamp)(ivec2s v, int minVal, int maxVal) {
+  glm_ivec2_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @returns     destination
+ */
+CGLM_INLINE
+ivec2s
+glms_ivec2_(abs)(ivec2s v) {
+  ivec2s r;
+  glm_ivec2_abs(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_ivec2_h */

include/cglm/struct/ivec3.h

@@ -0,0 +1,725 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+  GLMS_IVEC3_ONE_INIT
+  GLMS_IVEC3_ZERO_INIT
+  GLMS_IVEC3_ONE
+  GLMS_IVEC3_ZERO
+
+ Functions:
+  CGLM_INLINE ivec3s glms_ivec3(ivec4s v4)
+  CGLM_INLINE void glms_ivec3_pack(ivec3s dst[], ivec3 src[], size_t len)
+  CGLM_INLINE void glms_ivec3_unpack(ivec3 dst[], ivec3s src[], size_t len)
+  CGLM_INLINE ivec3s glms_ivec3_zero(void)
+  CGLM_INLINE ivec3s glms_ivec3_one(void)
+  CGLM_INLINE int glms_ivec3_dot(ivec3s a, ivec3s b)
+  CGLM_INLINE int glms_ivec3_norm2(ivec3s v)
+  CGLM_INLINE int glms_ivec3_norm(ivec3s v)
+  CGLM_INLINE ivec3s glms_ivec3_add(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_adds(ivec3s v, int s)
+  CGLM_INLINE ivec3s glms_ivec3_sub(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_subs(ivec3s v, int s)
+  CGLM_INLINE ivec3s glms_ivec3_mul(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_scale(ivec3s v, int s)
+  CGLM_INLINE ivec3s glms_ivec3_div(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_divs(ivec3s v, int s)
+  CGLM_INLINE ivec3s glms_ivec3_mod(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_addadd(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_addadds(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_subadd(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_subadds(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_muladd(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_muladds(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_minadd(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_subsub(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_subsubs(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_addsub(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_addsubs(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_mulsub(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_mulsubs(ivec3s a, int s, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_maxsub(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE ivec3s glms_ivec3_minsub(ivec3s a, ivec3s b, ivec3s dest)
+  CGLM_INLINE int glms_ivec3_distance2(ivec3s a, ivec3s b)
+  CGLM_INLINE float glms_ivec3_distance(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_fill(int val)
+  CGLM_INLINE bool glms_ivec3_eq(ivec3s v, int val)
+  CGLM_INLINE bool glms_ivec3_eqv(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_maxv(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_minv(ivec3s a, ivec3s b)
+  CGLM_INLINE ivec3s glms_ivec3_clamp(ivec3s v, int minVal, int maxVal)
+  CGLM_INLINE ivec3s glms_ivec3_abs(ivec3s v)
+ */
+
+#ifndef cglms_ivec3_h
+#define cglms_ivec3_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../ivec3.h"
+
+#define glms_ivec3_(NAME) CGLM_STRUCTAPI(ivec3, NAME)
+
+#define GLMS_IVEC3_ONE_INIT   {GLM_IVEC3_ONE_INIT}
+#define GLMS_IVEC3_ZERO_INIT  {GLM_IVEC3_ZERO_INIT}
+
+#define GLMS_IVEC3_ONE  ((ivec3s)GLMS_IVEC3_ONE_INIT)
+#define GLMS_IVEC3_ZERO ((ivec3s)GLMS_IVEC3_ZERO_INIT)
+
+/*!
+ * @brief init ivec3 using ivec4
+ *
+ * @param[in]  v4   vector4
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3(ivec4s v4) {
+  ivec3s r;
+  glm_ivec3(v4.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of ivec3 into an array of ivec3s
+ *
+ * @param[out] dst array of ivec3s
+ * @param[in]  src array of ivec3
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec3_(pack)(ivec3s dst[], ivec3 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec3_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of ivec3s into an array of ivec3
+ *
+ * @param[out] dst array of ivec3
+ * @param[in]  src array of ivec3s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec3_(unpack)(ivec3 dst[], ivec3s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec3_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec3s 
+glms_ivec3_(zero)(void) {
+  ivec3s r;
+  glm_ivec3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(one)(void) {
+  ivec3s r;
+  glm_ivec3_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief ivec3 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+int
+glms_ivec3_(dot)(ivec3s a, ivec3s b) {
+  return glm_ivec3_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+int
+glms_ivec3_(norm2)(ivec3s v) {
+  return glm_ivec3_norm2(v.raw);
+}
+
+/*!
+ * @brief euclidean norm (magnitude), also called L2 norm
+ *        this will give magnitude of vector in euclidean space
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+int
+glms_ivec3_(norm)(ivec3s v) {
+  return glm_ivec3_norm(v.raw);
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(add)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(adds)(ivec3s v, int s) {
+  ivec3s r;
+  glm_ivec3_adds(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(sub)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(subs)(ivec3s v, int s) {
+  ivec3s r;
+  glm_ivec3_subs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(mul)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(scale)(ivec3s v, int s) {
+  ivec3s r;
+  glm_ivec3_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(div)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(divs)(ivec3s v, int s) {
+  ivec3s r;
+  glm_ivec3_divs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief Element-wise modulo operation on ivec3 vectors: dest = a % b
+ *
+ * Performs element-wise modulo on each component of vectors `a` and `b`.
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]%b[0], a[1]%b[1], a[2]%b[2])
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(mod)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_mod(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add vector [a] with vector [b] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(addadd)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] onto vector [a] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a + s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(addadds)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_addadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a - b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(subadd)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(subadds)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_subadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(muladd)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(muladds)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add maximum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(maxadd)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add minimum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(minadd)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= (a - b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(subsub)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_subsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(subsubs)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_subsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(addsub)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_addsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] to vector [a] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(addsubs)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_addsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] and vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(mulsub)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_mulsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(mulsubs)(ivec3s a, int s, ivec3s dest) {
+  glm_ivec3_mulsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract maximum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(maxsub)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_maxsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract minimum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec3s 
+glms_ivec3_(minsub)(ivec3s a, ivec3s b, ivec3s dest) {
+  glm_ivec3_minsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glms_ivec3_(distance2)(ivec3s a, ivec3s b) {
+  return glm_ivec3_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glms_ivec3_(distance)(ivec3s a, ivec3s b) {
+  return glm_ivec3_distance(a.raw, b.raw);
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val value
+ * @returns        destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(fill)(int val) {
+  ivec3s r;
+  glm_ivec3_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_ivec3_(eq)(ivec3s v, int val) {
+  return glm_ivec3_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to another
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_ivec3_(eqv)(ivec3s a, ivec3s b) {
+  return glm_ivec3_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(maxv)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(minv)(ivec3s a, ivec3s b) {
+  ivec3s r;
+  glm_ivec3_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in]      v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ * @returns               clamped vector
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(clamp)(ivec3s v, int minVal, int maxVal) {
+  glm_ivec3_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @returns     destination
+ */
+CGLM_INLINE
+ivec3s
+glms_ivec3_(abs)(ivec3s v) {
+  ivec3s r;
+  glm_ivec3_abs(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_ivec3_h */

include/cglm/struct/ivec4.h

@@ -0,0 +1,588 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+  GLMS_IVEC4_ONE_INIT
+  GLMS_IVEC4_ZERO_INIT
+  GLMS_IVEC4_ONE
+  GLMS_IVEC4_ZERO
+
+ Functions:
+  CGLM_INLINE ivec4s glms_ivec4(ivec3s v3, int last)
+  CGLM_INLINE void glms_ivec4_pack(ivec4s dst[], ivec4 src[], size_t len)
+  CGLM_INLINE void glms_ivec4_unpack(ivec4 dst[], ivec4s src[], size_t len)
+  CGLM_INLINE ivec4s  glms_ivec4_zero(void)
+  CGLM_INLINE ivec4s glms_ivec4_one(void)
+  CGLM_INLINE ivec4s glms_ivec4_add(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_adds(ivec4s v, int s)
+  CGLM_INLINE ivec4s glms_ivec4_sub(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_subs(ivec4s v, int s)
+  CGLM_INLINE ivec4s glms_ivec4_mul(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_scale(ivec4s v, int s)
+  CGLM_INLINE ivec4s glms_ivec4_addadd(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_addadds(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_subadd(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_subadds(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_muladd(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_muladds(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_maxadd(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_minadd(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_subsub(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_subsubs(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_addsub(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_addsubs(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_mulsub(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_mulsubs(ivec4s a, int s, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_maxsub(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE ivec4s glms_ivec4_minsub(ivec4s a, ivec4s b, ivec4s dest)
+  CGLM_INLINE int glms_ivec4_distance2(ivec4s a, ivec4s b)
+  CGLM_INLINE float glms_ivec4_distance(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_maxv(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_minv(ivec4s a, ivec4s b)
+  CGLM_INLINE ivec4s glms_ivec4_clamp(ivec4s v, int minVal, int maxVal)
+  CGLM_INLINE ivec4s glms_ivec4_abs(ivec4s v)
+ */
+
+#ifndef cglms_ivec4_h
+#define cglms_ivec4_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../ivec4.h"
+
+#define glms_ivec4_(NAME) CGLM_STRUCTAPI(ivec4, NAME)
+
+#define GLMS_IVEC4_ONE_INIT   {GLM_IVEC4_ONE_INIT}
+#define GLMS_IVEC4_ZERO_INIT  {GLM_IVEC4_ZERO_INIT}
+
+#define GLMS_IVEC4_ONE  ((ivec4s)GLMS_IVEC4_ONE_INIT)
+#define GLMS_IVEC4_ZERO ((ivec4s)GLMS_IVEC4_ZERO_INIT)
+
+/*!
+ * @brief init ivec4 using ivec3
+ *
+ * @param[in]  v3   vector3
+ * @param[in]  last last item
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4(ivec3s v3, int last) {
+  ivec4s r;
+  glm_ivec4(v3.raw, last, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of ivec4 into an array of ivec4s
+ *
+ * @param[out] dst array of ivec4s
+ * @param[in]  src array of ivec4
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec4_(pack)(ivec4s dst[], ivec4 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec4_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of ivec4s into an array of ivec4
+ *
+ * @param[out] dst array of ivec4
+ * @param[in]  src array of ivec4s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_ivec4_(unpack)(ivec4 dst[], ivec4s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_ivec4_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec4s 
+glms_ivec4_(zero)(void) {
+  ivec4s r;
+  glm_ivec4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @returns vector
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(one)(void) {
+  ivec4s r;
+  glm_ivec4_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(add)(ivec4s a, ivec4s b) {
+  ivec4s r;
+  glm_ivec4_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(adds)(ivec4s v, int s) {
+  ivec4s r;
+  glm_ivec4_adds(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(sub)(ivec4s a, ivec4s b) {
+  ivec4s r;
+  glm_ivec4_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(subs)(ivec4s v, int s) {
+  ivec4s r;
+  glm_ivec4_subs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(mul)(ivec4s a, ivec4s b) {
+  ivec4s r;
+  glm_ivec4_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(scale)(ivec4s v, int s) {
+  ivec4s r;
+  glm_ivec4_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add vector [a] with vector [b] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(addadd)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] onto vector [a] and add result to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a + s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(addadds)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_addadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a - b)  
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(subadd)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(subadds)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_subadds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(muladd)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and add result to [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest += (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(muladds)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add maximum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(maxadd)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add minimum of vector [a] and vector [b] to vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest += min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(minadd)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract vector [a] from vector [b] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= (a - b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(subsub)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_subsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract scalar [s] from vector [a] and subtract result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a - s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(subsubs)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_subsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(addsub)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_addsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add scalar [s] to vector [a] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a + b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(addsubs)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_addsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] and vector [b] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  b    scalar
+ * @param[in]  dest dest -= (a * b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(mulsub)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_mulsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiply vector [a] with scalar [s] and subtract the result from [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[in]  dest dest -= (a * s)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(mulsubs)(ivec4s a, int s, ivec4s dest) {
+  glm_ivec4_mulsubs(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract maximum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies += operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= max(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(maxsub)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_maxsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract minimum of vector [a] and vector [b] from vector [dest]
+ *
+ * applies -= operator so dest must be initialized
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[in]  dest dest -= min(a, b)
+ * @returns         dest
+ */
+CGLM_INLINE 
+ivec4s 
+glms_ivec4_(minsub)(ivec4s a, ivec4s b, ivec4s dest) {
+  glm_ivec4_minsub(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glms_ivec4_(distance2)(ivec4s a, ivec4s b) {
+  return glm_ivec4_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glms_ivec4_(distance)(ivec4s a, ivec4s b) {
+  return glm_ivec4_distance(a.raw, b.raw);
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(maxv)(ivec4s a, ivec4s b) {
+  ivec4s r;
+  glm_ivec4_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @returns         destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(minv)(ivec4s a, ivec4s b) {
+  ivec4s r;
+  glm_ivec4_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in]      v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ * @returns               clamped vector
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(clamp)(ivec4s v, int minVal, int maxVal) {
+  glm_ivec4_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @returns     destination
+ */
+CGLM_INLINE
+ivec4s
+glms_ivec4_(abs)(ivec4s v) {
+  ivec4s r;
+  glm_ivec4_abs(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_ivec4_h */