vec3.h 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. /******************************************************************************
  2. Copyright (C) 2023 by Lain Bailey <[email protected]>
  3. This program is free software: you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation, either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>.
  13. ******************************************************************************/
  14. #pragma once
  15. #include "math-defs.h"
  16. #include "vec4.h"
  17. #include "../util/sse-intrin.h"
  18. #ifdef __cplusplus
  19. extern "C" {
  20. #endif
  21. struct plane;
  22. struct matrix3;
  23. struct matrix4;
  24. struct quat;
  25. struct vec3 {
  26. union {
  27. struct {
  28. float x, y, z, w;
  29. };
  30. float ptr[4];
  31. __m128 m;
  32. };
  33. };
  34. static inline void vec3_zero(struct vec3 *v)
  35. {
  36. v->m = _mm_setzero_ps();
  37. }
  38. static inline void vec3_set(struct vec3 *dst, float x, float y, float z)
  39. {
  40. dst->m = _mm_set_ps(0.0f, z, y, x);
  41. }
  42. static inline void vec3_copy(struct vec3 *dst, const struct vec3 *v)
  43. {
  44. dst->m = v->m;
  45. }
  46. EXPORT void vec3_from_vec4(struct vec3 *dst, const struct vec4 *v);
  47. static inline void vec3_add(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  48. {
  49. dst->m = _mm_add_ps(v1->m, v2->m);
  50. dst->w = 0.0f;
  51. }
  52. static inline void vec3_sub(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  53. {
  54. dst->m = _mm_sub_ps(v1->m, v2->m);
  55. dst->w = 0.0f;
  56. }
  57. static inline void vec3_mul(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  58. {
  59. dst->m = _mm_mul_ps(v1->m, v2->m);
  60. }
  61. static inline void vec3_div(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  62. {
  63. dst->m = _mm_div_ps(v1->m, v2->m);
  64. dst->w = 0.0f;
  65. }
  66. static inline void vec3_addf(struct vec3 *dst, const struct vec3 *v, float f)
  67. {
  68. dst->m = _mm_add_ps(v->m, _mm_set1_ps(f));
  69. dst->w = 0.0f;
  70. }
  71. static inline void vec3_subf(struct vec3 *dst, const struct vec3 *v, float f)
  72. {
  73. dst->m = _mm_sub_ps(v->m, _mm_set1_ps(f));
  74. dst->w = 0.0f;
  75. }
  76. static inline void vec3_mulf(struct vec3 *dst, const struct vec3 *v, float f)
  77. {
  78. dst->m = _mm_mul_ps(v->m, _mm_set1_ps(f));
  79. }
  80. static inline void vec3_divf(struct vec3 *dst, const struct vec3 *v, float f)
  81. {
  82. dst->m = _mm_div_ps(v->m, _mm_set1_ps(f));
  83. dst->w = 0.0f;
  84. }
  85. static inline float vec3_dot(const struct vec3 *v1, const struct vec3 *v2)
  86. {
  87. struct vec3 add;
  88. __m128 mul = _mm_mul_ps(v1->m, v2->m);
  89. add.m = _mm_add_ps(_mm_movehl_ps(mul, mul), mul);
  90. add.m = _mm_add_ps(_mm_shuffle_ps(add.m, add.m, 0x55), add.m);
  91. return add.x;
  92. }
  93. static inline void vec3_cross(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  94. {
  95. __m128 s1v1 = _mm_shuffle_ps(v1->m, v1->m, _MM_SHUFFLE(3, 0, 2, 1));
  96. __m128 s1v2 = _mm_shuffle_ps(v2->m, v2->m, _MM_SHUFFLE(3, 1, 0, 2));
  97. __m128 s2v1 = _mm_shuffle_ps(v1->m, v1->m, _MM_SHUFFLE(3, 1, 0, 2));
  98. __m128 s2v2 = _mm_shuffle_ps(v2->m, v2->m, _MM_SHUFFLE(3, 0, 2, 1));
  99. dst->m = _mm_sub_ps(_mm_mul_ps(s1v1, s1v2), _mm_mul_ps(s2v1, s2v2));
  100. }
  101. static inline void vec3_neg(struct vec3 *dst, const struct vec3 *v)
  102. {
  103. dst->x = -v->x;
  104. dst->y = -v->y;
  105. dst->z = -v->z;
  106. dst->w = 0.0f;
  107. }
  108. static inline float vec3_len(const struct vec3 *v)
  109. {
  110. float dot_val = vec3_dot(v, v);
  111. return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
  112. }
  113. static inline float vec3_dist(const struct vec3 *v1, const struct vec3 *v2)
  114. {
  115. struct vec3 temp;
  116. float dot_val;
  117. vec3_sub(&temp, v1, v2);
  118. dot_val = vec3_dot(&temp, &temp);
  119. return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
  120. }
  121. static inline void vec3_norm(struct vec3 *dst, const struct vec3 *v)
  122. {
  123. float dot_val = vec3_dot(v, v);
  124. dst->m = (dot_val > 0.0f) ? _mm_mul_ps(v->m, _mm_set1_ps(1.0f / sqrtf(dot_val))) : _mm_setzero_ps();
  125. }
  126. static inline bool vec3_close(const struct vec3 *v1, const struct vec3 *v2, float epsilon)
  127. {
  128. struct vec3 test;
  129. vec3_sub(&test, v1, v2);
  130. return test.x < epsilon && test.y < epsilon && test.z < epsilon;
  131. }
  132. static inline void vec3_min(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  133. {
  134. dst->m = _mm_min_ps(v1->m, v2->m);
  135. dst->w = 0.0f;
  136. }
  137. static inline void vec3_minf(struct vec3 *dst, const struct vec3 *v, float f)
  138. {
  139. dst->m = _mm_min_ps(v->m, _mm_set1_ps(f));
  140. dst->w = 0.0f;
  141. }
  142. static inline void vec3_max(struct vec3 *dst, const struct vec3 *v1, const struct vec3 *v2)
  143. {
  144. dst->m = _mm_max_ps(v1->m, v2->m);
  145. dst->w = 0.0f;
  146. }
  147. static inline void vec3_maxf(struct vec3 *dst, const struct vec3 *v, float f)
  148. {
  149. dst->m = _mm_max_ps(v->m, _mm_set1_ps(f));
  150. dst->w = 0.0f;
  151. }
  152. static inline void vec3_abs(struct vec3 *dst, const struct vec3 *v)
  153. {
  154. dst->x = fabsf(v->x);
  155. dst->y = fabsf(v->y);
  156. dst->z = fabsf(v->z);
  157. dst->w = 0.0f;
  158. }
  159. static inline void vec3_floor(struct vec3 *dst, const struct vec3 *v)
  160. {
  161. dst->x = floorf(v->x);
  162. dst->y = floorf(v->y);
  163. dst->z = floorf(v->z);
  164. dst->w = 0.0f;
  165. }
  166. static inline void vec3_ceil(struct vec3 *dst, const struct vec3 *v)
  167. {
  168. dst->x = ceilf(v->x);
  169. dst->y = ceilf(v->y);
  170. dst->z = ceilf(v->z);
  171. dst->w = 0.0f;
  172. }
  173. EXPORT float vec3_plane_dist(const struct vec3 *v, const struct plane *p);
  174. EXPORT void vec3_transform(struct vec3 *dst, const struct vec3 *v, const struct matrix4 *m);
  175. EXPORT void vec3_rotate(struct vec3 *dst, const struct vec3 *v, const struct matrix3 *m);
  176. EXPORT void vec3_transform3x4(struct vec3 *dst, const struct vec3 *v, const struct matrix3 *m);
  177. EXPORT void vec3_mirror(struct vec3 *dst, const struct vec3 *v, const struct plane *p);
  178. EXPORT void vec3_mirrorv(struct vec3 *dst, const struct vec3 *v, const struct vec3 *vec);
  179. EXPORT void vec3_rand(struct vec3 *dst, int positive_only);
  180. #ifdef __cplusplus
  181. }
  182. #endif