Revert "mark readonly parameters as const"

src/vec4.c

@@ -10,7 +10,7 @@
 
 CGLM_EXPORT
 void
-glmc_vec4(const vec3 v3, float last, vec4 dest) {
+glmc_vec4(vec3 v3, float last, vec4 dest) {
   glm_vec4(v3, last, dest);
 }
 
@@ -28,37 +28,37 @@ glmc_vec4_one(vec4 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_copy3(const vec4 v, vec3 dest) {
+glmc_vec4_copy3(vec4 v, vec3 dest) {
   glm_vec4_copy3(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_copy(const vec4 v, vec4 dest) {
+glmc_vec4_copy(vec4 v, vec4 dest) {
   glm_vec4_copy(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_ucopy(const vec4 v, vec4 dest) {
+glmc_vec4_ucopy(vec4 v, vec4 dest) {
   glm_vec4_ucopy(v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_dot(const vec4 a, const vec4 b) {
+glmc_vec4_dot(vec4 a, vec4 b) {
   return glm_vec4_dot(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_norm(const vec4 v) {
+glmc_vec4_norm(vec4 v) {
   return glm_vec4_norm(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_normalize_to(const vec4 v, vec4 dest) {
+glmc_vec4_normalize_to(vec4 v, vec4 dest) {
   glm_vec4_normalize_to(v, dest);
 }
 
@@ -70,97 +70,97 @@ glmc_vec4_normalize(vec4 v) {
 
 CGLM_EXPORT
 float
-glmc_vec4_norm2(const vec4 v) {
+glmc_vec4_norm2(vec4 v) {
   return glm_vec4_norm2(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_add(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_add(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_adds(const vec4 v, float s, vec4 dest) {
+glmc_vec4_adds(vec4 v, float s, vec4 dest) {
   glm_vec4_adds(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_sub(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_sub(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_subs(const vec4 v, float s, vec4 dest) {
+glmc_vec4_subs(vec4 v, float s, vec4 dest) {
   glm_vec4_subs(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d) {
+glmc_vec4_mul(vec4 a, vec4 b, vec4 d) {
   glm_vec4_mul(a, b, d);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_scale(const vec4 v, float s, vec4 dest) {
+glmc_vec4_scale(vec4 v, float s, vec4 dest) {
   glm_vec4_scale(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_scale_as(const vec4 v, float s, vec4 dest) {
+glmc_vec4_scale_as(vec4 v, float s, vec4 dest) {
   glm_vec4_scale_as(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_div(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_div(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_divs(const vec4 v, float s, vec4 dest) {
+glmc_vec4_divs(vec4 v, float s, vec4 dest) {
   glm_vec4_divs(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_addadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_subadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_muladd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_muladds(const vec4 a, float s, vec4 dest) {
+glmc_vec4_muladds(vec4 a, float s, vec4 dest) {
   glm_vec4_muladds(a, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_maxadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_minadd(a, b, dest);
 }
 
@@ -172,25 +172,25 @@ glmc_vec4_negate(vec4 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_negate_to(const vec4 v, vec4 dest) {
+glmc_vec4_negate_to(vec4 v, vec4 dest) {
   glm_vec4_negate_to(v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_distance(const vec4 a, const vec4 b) {
+glmc_vec4_distance(vec4 a, vec4 b) {
   return glm_vec4_distance(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_minv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
+glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
   glm_vec4_maxv(a, b, dest);
 }
 
@@ -202,7 +202,7 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal) {
 
 CGLM_EXPORT
 void
-glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
+glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
@@ -216,7 +216,7 @@ glmc_vec4_cubic(float s, vec4 dest) {
 
 CGLM_EXPORT
 void
-glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d) {
+glmc_vec4_mulv(vec4 a, vec4 b, vec4 d) {
   glm_vec4_mulv(a, b, d);
 }
 
@@ -228,72 +228,72 @@ glmc_vec4_broadcast(float val, vec4 d) {
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq(const vec4 v, float val) {
+glmc_vec4_eq(vec4 v, float val) {
   return glm_vec4_eq(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_eps(const vec4 v, float val) {
+glmc_vec4_eq_eps(vec4 v, float val) {
   return glm_vec4_eq_eps(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_all(const vec4 v) {
+glmc_vec4_eq_all(vec4 v) {
   return glm_vec4_eq_all(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv(const vec4 a, const vec4 b) {
+glmc_vec4_eqv(vec4 a, vec4 b) {
   return glm_vec4_eqv(a, b);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv_eps(const vec4 a, const vec4 b) {
+glmc_vec4_eqv_eps(vec4 a, vec4 b) {
   return glm_vec4_eqv_eps(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_max(const vec4 v) {
+glmc_vec4_max(vec4 v) {
   return glm_vec4_max(v);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_min(const vec4 v) {
+glmc_vec4_min(vec4 v) {
   return glm_vec4_min(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isnan(const vec4 v) {
+glmc_vec4_isnan(vec4 v) {
   return glm_vec4_isnan(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isinf(const vec4 v) {
+glmc_vec4_isinf(vec4 v) {
   return glm_vec4_isinf(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isvalid(const vec4 v) {
+glmc_vec4_isvalid(vec4 v) {
   return glm_vec4_isvalid(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sign(const vec4 v, vec4 dest) {
+glmc_vec4_sign(vec4 v, vec4 dest) {
   glm_vec4_sign(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sqrt(const vec4 v, vec4 dest) {
+glmc_vec4_sqrt(vec4 v, vec4 dest) {
   glm_vec4_sqrt(v, dest);
 }