vector3.inl - Engine C API Reference

vector3.inl
  1. #include "math.h"
  3. namespace stingray_plugin_foundation {
  5. // Operators
  6. __forceinline Vector3 operator / (const Vector3 &lhs, const Vector3 &rhs) {
  7.     return vector3(lhs.x/rhs.x, lhs.y/rhs.y, lhs.z/rhs.z);
  8. }
  10. __forceinline Vector3 operator * (const Vector3 &lhs, const Vector3 &rhs) {
  11.     return vector3(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z);
  12. }
  14. __forceinline Vector3 operator + (const Vector3 &lhs, const Vector3 &rhs) {
  15.     return vector3(lhs.x+rhs.x, lhs.y+rhs.y, lhs.z+rhs.z);
  16. }
  18. __forceinline Vector3 operator - (const Vector3 &lhs, const Vector3 &rhs) {
  19.     return vector3(lhs.x-rhs.x, lhs.y-rhs.y, lhs.z-rhs.z);
  20. }
  22. __forceinline Vector3 operator - (const Vector3 &v) {
  23.     return vector3(-v.x, -v.y, -v.z);
  24. }
  26. __forceinline Vector3 operator + (const Vector3 &v) {
  27.     return v;
  28. }
  30. __forceinline void operator /= (Vector3 &lhs, const Vector3 &rhs) {
  31.     lhs.x/=rhs.x; lhs.y/=rhs.y; lhs.z/=rhs.z;
  32. }
  34. __forceinline void operator *= (Vector3 &lhs, const Vector3 &rhs) {
  35.     lhs.x*=rhs.x; lhs.y*=rhs.y; lhs.z*=rhs.z;
  36. }
  38. __forceinline void operator += (Vector3 &lhs, const Vector3 &rhs) {
  39.     lhs.x+=rhs.x; lhs.y+=rhs.y; lhs.z+=rhs.z;
  40. }
  42. __forceinline void operator -= (Vector3 &lhs, const Vector3 &rhs) {
  43.     lhs.x-=rhs.x; lhs.y-=rhs.y; lhs.z-=rhs.z;
  44. }
  46. __forceinline Vector3 operator/(const Vector3 &lhs, float rhs) {
  47.     return vector3(lhs.x/rhs, lhs.y/rhs, lhs.z/rhs);
  48. }
  50. __forceinline Vector3 operator*(const Vector3 &lhs, float rhs) {
  51.     return vector3(lhs.x*rhs, lhs.y*rhs, lhs.z*rhs);
  52. }
  54. __forceinline Vector3 operator*(float lhs, const Vector3 &rhs) {
  55.     return vector3(rhs.x*lhs, rhs.y*lhs, rhs.z*lhs);
  56. }
  58. __forceinline Vector3 operator+(const Vector3 &lhs, float rhs) {
  59.     return vector3(lhs.x+rhs, lhs.y+rhs, lhs.z+rhs);
  60. }
  62. __forceinline Vector3 operator-(const Vector3 &lhs, float rhs) {
  63.     return vector3(lhs.x-rhs, lhs.y-rhs, lhs.z-rhs);
  64. }
  66. __forceinline void operator/=(Vector3 &lhs, float rhs) {
  67.     lhs.x/=rhs; lhs.y/=rhs; lhs.z/=rhs;
  68. }
  70. __forceinline void operator*=(Vector3 &lhs, float rhs) {
  71.     lhs.x*=rhs; lhs.y*=rhs; lhs.z*=rhs;
  72. }
  74. __forceinline void operator+=(Vector3 &lhs, float rhs) {
  75.     lhs.x+=rhs; lhs.y+=rhs; lhs.z+=rhs;
  76. }
  78. __forceinline void operator-=(Vector3 &lhs, float rhs) {
  79.     lhs.x-=rhs; lhs.y-=rhs; lhs.z-=rhs;
  80. }
  82. __forceinline bool operator==(const Vector3 &lhs, const Vector3 &rhs)
  83. {
  84.     return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
  85. }
  87. __forceinline bool operator!=(const Vector3 &lhs, const Vector3 &rhs)
  88. {
  89.     return !(lhs == rhs);
  90. }
  92. __forceinline bool operator< (const Vector3 &lhs, const Vector3 &rhs)
  93. {
  94.     if (lhs.x != rhs.x) return lhs.x < rhs.x;
  95.     if (lhs.y != rhs.y) return lhs.y < rhs.y;
  96.     return lhs.z < rhs.z;
  97. }
  99. __forceinline bool operator<=(const Vector3 &lhs, const Vector3 &rhs)
  100. {
  101.     return (lhs < rhs) || (lhs == rhs);
  102. }
  104. __forceinline bool operator> (const Vector3 &lhs, const Vector3 &rhs)
  105. {
  106.     return (rhs < lhs);
  107. }
  109. __forceinline bool operator>=(const Vector3 &lhs, const Vector3 &rhs)
  110. {
  111.     return !(lhs < rhs);
  112. }
  114. // Methods
  115. __forceinline Vector3 vector3(float x, float y, float z) {
  116.     Vector3 v = {x, y, z};
  117.     return v;
  118. }
  120. __forceinline Vector3 vector3(const float v[3])
  121. {
  122.     Vector3 r = {v[0], v[1], v[2]};
  123.     return r;
  124. }
  126. __forceinline Vector3 vector3(const Vector2 &v) {
  127.     Vector3 r = { v.x, v.y, 0.f };
  128.     return r;
  129. }
  131. __forceinline Vector3 vector3(const Vector2 &v, float z) {
  132.     Vector3 r = { v.x, v.y, z };
  133.     return r;
  134. }
  136. __forceinline Vector3 vector3_base(int i)
  137. {
  138.     if (i==0)
  139.         return vector3(1,0,0);
  140.     else if (i==1)
  141.         return vector3(0,1,0);
  142.     else if (i==2)
  143.         return vector3(0,0,1);
  144.     return vector3(0,0,0);
  145. }
  147. __forceinline float & element(Vector3 &v, int i)
  148. {
  149.     return *(&v.x + i);
  150. }
  152. __forceinline const float & element(const Vector3 &v, int i)
  153. {
  154.     return *(&v.x + i);
  155. }
  157. __forceinline void zero(Vector3 &v) {
  158.     v.x=0.f; v.y=0.f; v.z=0.f;
  159. }
  161. __forceinline bool is_zero(const Vector3 &v)
  162. {
  163.     return v.x == 0.0f && v.y == 0.0f && v.z == 0.0f;
  164. }
  166. __forceinline bool is_zero(const Vector3 &v, float eps)
  167. {
  168.     return length_squared(v) <= eps*eps;
  169. }
  171. __forceinline float length(const Vector3 &v) {
  172.     return math::square_root(v.x*v.x + v.y*v.y + v.z*v.z);
  173. }
  175. __forceinline float length_squared(const Vector3 &v) {
  176.     return v.x*v.x + v.y*v.y + v.z*v.z;
  177. }
  179. __forceinline float norm(const Vector3 &v)
  180. {
  181.     return math::square_root(v.x*v.x + v.y*v.y + v.z*v.z);
  182. }
  184. __forceinline float one_norm(const Vector3 &v)
  185. {
  186.     return math::abs(v.x) + math::abs(v.y) + math::abs(v.z);
  187. }
  189. __forceinline float infinity_norm(const Vector3 &v)
  190. {
  191.     return math::max3( math::abs(v.x), math::abs(v.y), math::abs(v.z) );
  192. }
  194. __forceinline Vector3 normalize(const Vector3 &v) {
  195.     float l=length(v);
  196.     if (l<0.0001)
  197.         return vector3(0.f, 0.f, 0.f);
  198.     return v / l;
  199. }
  201. __forceinline float dot(const Vector3 &v0, const Vector3 &v1) {
  202.     return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
  203. }
  205. __forceinline Vector3 cross(const Vector3 &v0, const Vector3 &v1) {
  206.     return vector3((v0.y*v1.z)-(v0.z*v1.y),(v0.z*v1.x)-(v0.x*v1.z),(v0.x*v1.y)-(v0.y*v1.x));
  207. }
  209. __forceinline float distance(const Vector3 &v0, const Vector3 &v1) {
  210.     Vector3 tmp = vector3(v0.x-v1.x,v0.y-v1.y,v0.z-v1.z);
  211.     return length(tmp);
  212. }
  214. __forceinline float distance_squared(const Vector3 &v0, const Vector3 &v1) {
  215.     return (v0.x-v1.x)*(v0.x-v1.x) + (v0.y-v1.y)*(v0.y-v1.y) + (v0.z-v1.z)*(v0.z-v1.z);
  216. }
  218. __forceinline Vector3 normal_vector(const Vector3 &v0,const Vector3 &v1, const Vector3& v2){
  219.     return cross(v1-v0,v2-v0);
  220. }
  222. __forceinline Vector3 orthonormalize(const Vector3 &v, const Vector3 &ref)
  223. {
  224.     Vector3 res = v - dot(v, ref) * ref;
  225.     return normalize(res);
  226. }
  228. __forceinline Vector3 min(const Vector3 &v0, const Vector3 &v1)
  229. {
  230.     return vector3(math::min(v0.x,v1.x), math::min(v0.y,v1.y), math::min(v0.z,v1.z));
  231. }
  233. __forceinline Vector3 max(const Vector3 &v0, const Vector3 &v1)
  234. {
  235.     return vector3(math::max(v0.x,v1.x), math::max(v0.y,v1.y), math::max(v0.z,v1.z));
  236. }
  238. __forceinline bool all_gt(const Vector3& p1, const Vector3& p2)
  239. {
  240.     return p1.x > p2.x && p1.y > p2.y && p1.z > p2.z;
  241. }
  243. __forceinline bool all_lt(const Vector3& p1, const Vector3& p2)
  244. {
  245.     return p1.x < p2.x && p1.y < p2.y && p1.z < p2.z;
  246. }
  248. __forceinline void make_axes(const Vector3 &x, Vector3 &y, Vector3 &z)
  249. {
  250.     if (x.z > -0.5 && x.z < 0.5) {
  251.         y = vector3(-x.y, x.x, 0);
  252.         y = orthonormalize(y, x);
  253.         z = cross(x, y);
  254.     } else {
  255.         y = vector3(0, x.z, -x.y);
  256.         y = orthonormalize(y, x);
  257.         z = cross(x,y);
  258.     }
  259. }
  261. __forceinline Vector3 lerp(const Vector3 &a, const Vector3 &b, float p)
  262. {
  263.     return a * (1-p) + b * p;
  264. }
  266. __forceinline MagnitudeAndDirection magnitude_and_direction(const Vector3 &v)
  267. {
  268.     MagnitudeAndDirection md;
  269.     md.magnitude = norm(v);
  270.     md.direction = md.magnitude > 0 ? v / md.magnitude : vector3(0,0,0);
  271.     return md;
  272. }
  274. }
Please send us your comment about this page