matrix4x4.inl - Engine C API Reference

matrix4x4.inl
  1. #include "vector3.h"
  3. namespace stingray_plugin_foundation {
  5. enum Elements {
  6.     xx, xy, xz, xw,
  7.     yx, yy, yz, yw,
  8.     zx, zy, zz, zw,
  9.     tx, ty, tz, tw
  10. };
  12. // Operators
  14. __forceinline Matrix4x4 operator *(const Matrix4x4& lhs, const Matrix4x4 &rhs) {
  15.     Matrix4x4 m = {{
  16.         lhs.v[xx]*rhs.v[xx] + lhs.v[xy]*rhs.v[yx] + lhs.v[xz]*rhs.v[zx] + lhs.v[xw]*rhs.v[tx],
  17.         lhs.v[xx]*rhs.v[xy] + lhs.v[xy]*rhs.v[yy] + lhs.v[xz]*rhs.v[zy] + lhs.v[xw]*rhs.v[ty],
  18.         lhs.v[xx]*rhs.v[xz] + lhs.v[xy]*rhs.v[yz] + lhs.v[xz]*rhs.v[zz] + lhs.v[xw]*rhs.v[tz],
  19.         lhs.v[xx]*rhs.v[xw] + lhs.v[xy]*rhs.v[yw] + lhs.v[xz]*rhs.v[zw] + lhs.v[xw]*rhs.v[tw],
  20.         lhs.v[yx]*rhs.v[xx] + lhs.v[yy]*rhs.v[yx] + lhs.v[yz]*rhs.v[zx] + lhs.v[yw]*rhs.v[tx],
  21.         lhs.v[yx]*rhs.v[xy] + lhs.v[yy]*rhs.v[yy] + lhs.v[yz]*rhs.v[zy] + lhs.v[yw]*rhs.v[ty],
  22.         lhs.v[yx]*rhs.v[xz] + lhs.v[yy]*rhs.v[yz] + lhs.v[yz]*rhs.v[zz] + lhs.v[yw]*rhs.v[tz],
  23.         lhs.v[yx]*rhs.v[xw] + lhs.v[yy]*rhs.v[yw] + lhs.v[yz]*rhs.v[zw] + lhs.v[yw]*rhs.v[tw],
  24.         lhs.v[zx]*rhs.v[xx] + lhs.v[zy]*rhs.v[yx] + lhs.v[zz]*rhs.v[zx] + lhs.v[zw]*rhs.v[tx],
  25.         lhs.v[zx]*rhs.v[xy] + lhs.v[zy]*rhs.v[yy] + lhs.v[zz]*rhs.v[zy] + lhs.v[zw]*rhs.v[ty],
  26.         lhs.v[zx]*rhs.v[xz] + lhs.v[zy]*rhs.v[yz] + lhs.v[zz]*rhs.v[zz] + lhs.v[zw]*rhs.v[tz],
  27.         lhs.v[zx]*rhs.v[xw] + lhs.v[zy]*rhs.v[yw] + lhs.v[zz]*rhs.v[zw] + lhs.v[zw]*rhs.v[tw],
  28.         lhs.v[tx]*rhs.v[xx] + lhs.v[ty]*rhs.v[yx] + lhs.v[tz]*rhs.v[zx] + lhs.v[tw]*rhs.v[tx],
  29.         lhs.v[tx]*rhs.v[xy] + lhs.v[ty]*rhs.v[yy] + lhs.v[tz]*rhs.v[zy] + lhs.v[tw]*rhs.v[ty],
  30.         lhs.v[tx]*rhs.v[xz] + lhs.v[ty]*rhs.v[yz] + lhs.v[tz]*rhs.v[zz] + lhs.v[tw]*rhs.v[tz],
  31.         lhs.v[tx]*rhs.v[xw] + lhs.v[ty]*rhs.v[yw] + lhs.v[tz]*rhs.v[zw] + lhs.v[tw]*rhs.v[tw]
  32.     }};
  34.     return m;
  35. }
  37. __forceinline Matrix4x4 operator +(const Matrix4x4& lhs, const Matrix4x4 &rhs) {
  38.     Matrix4x4 m = {{
  39.         lhs.v[xx] + rhs.v[xx], lhs.v[xy] + rhs.v[xy], lhs.v[xz] + rhs.v[xz], lhs.v[xw] + rhs.v[xw],
  40.         lhs.v[yx] + rhs.v[yx], lhs.v[yy] + rhs.v[yy], lhs.v[yz] + rhs.v[yz], lhs.v[yw] + rhs.v[yw],
  41.         lhs.v[zx] + rhs.v[zx], lhs.v[zy] + rhs.v[zy], lhs.v[zz] + rhs.v[zz], lhs.v[zw] + rhs.v[zw],
  42.         lhs.v[tx] + rhs.v[tx], lhs.v[ty] + rhs.v[ty], lhs.v[tz] + rhs.v[tz], lhs.v[tw] + rhs.v[tw]
  43.     }};
  44.     return m;
  45. }
  47. __forceinline Matrix4x4 operator -(const Matrix4x4& lhs, const Matrix4x4 &rhs) {
  48.     Matrix4x4 m = {{
  49.         lhs.v[xx] - rhs.v[xx], lhs.v[xy] - rhs.v[xy], lhs.v[xz] - rhs.v[xz], lhs.v[xw] - rhs.v[xw],
  50.         lhs.v[yx] - rhs.v[yx], lhs.v[yy] - rhs.v[yy], lhs.v[yz] - rhs.v[yz], lhs.v[yw] - rhs.v[yw],
  51.         lhs.v[zx] - rhs.v[zx], lhs.v[zy] - rhs.v[zy], lhs.v[zz] - rhs.v[zz], lhs.v[zw] - rhs.v[zw],
  52.         lhs.v[tx] - rhs.v[tx], lhs.v[ty] - rhs.v[ty], lhs.v[tz] - rhs.v[tz], lhs.v[tw] - rhs.v[tw]
  53.     }};
  54.     return m;
  55. }
  57. __forceinline void operator *=(Matrix4x4& lhs, const Matrix4x4 &rhs) {
  58.     Matrix4x4 tmp = lhs * rhs;
  59.     lhs = tmp;
  60. }
  62. __forceinline void operator +=(Matrix4x4& lhs, const Matrix4x4 &rhs) {
  63.     lhs.v[xx] += rhs.v[xx]; lhs.v[xy] += rhs.v[xy]; lhs.v[xz] += rhs.v[xz]; lhs.v[xw] += rhs.v[xw];
  64.     lhs.v[yx] += rhs.v[yx]; lhs.v[yy] += rhs.v[yy]; lhs.v[yz] += rhs.v[yz]; lhs.v[yw] += rhs.v[yw];
  65.     lhs.v[zx] += rhs.v[zx]; lhs.v[zy] += rhs.v[zy]; lhs.v[zz] += rhs.v[zz]; lhs.v[zw] += rhs.v[zw];
  66.     lhs.v[tx] += rhs.v[tx]; lhs.v[ty] += rhs.v[ty]; lhs.v[tz] += rhs.v[tz]; lhs.v[tw] += rhs.v[tw];
  67. }
  69. __forceinline void operator -=(Matrix4x4& lhs, const Matrix4x4 &rhs) {
  70.     lhs.v[xx] -= rhs.v[xx]; lhs.v[xy] -= rhs.v[xy]; lhs.v[xz] -= rhs.v[xz]; lhs.v[xw] -= rhs.v[xw];
  71.     lhs.v[yx] -= rhs.v[yx]; lhs.v[yy] -= rhs.v[yy]; lhs.v[yz] -= rhs.v[yz]; lhs.v[yw] -= rhs.v[yw];
  72.     lhs.v[zx] -= rhs.v[zx]; lhs.v[zy] -= rhs.v[zy]; lhs.v[zz] -= rhs.v[zz]; lhs.v[zw] -= rhs.v[zw];
  73.     lhs.v[tx] -= rhs.v[tx]; lhs.v[ty] -= rhs.v[ty]; lhs.v[tz] -= rhs.v[tz]; lhs.v[tw] -= rhs.v[tw];
  74. }
  76. __forceinline Matrix4x4 operator *(const Matrix4x4& lhs, float rhs) {
  77.     Matrix4x4 m = {{
  78.         lhs.v[xx] * rhs, lhs.v[xy] * rhs, lhs.v[xz] * rhs, lhs.v[xw] * rhs,
  79.         lhs.v[yx] * rhs, lhs.v[yy] * rhs, lhs.v[yz] * rhs, lhs.v[yw] * rhs,
  80.         lhs.v[zx] * rhs, lhs.v[zy] * rhs, lhs.v[zz] * rhs, lhs.v[zw] * rhs,
  81.         lhs.v[tx] * rhs, lhs.v[ty] * rhs, lhs.v[tz] * rhs, lhs.v[tw] * rhs
  82.     }};
  83.     return m;
  84. }
  86. __forceinline Matrix4x4 operator *(float lhs, const Matrix4x4 &rhs) {
  87.     return rhs * lhs;
  88. }
  90. __forceinline bool operator==(const Matrix4x4 &lhs, const Matrix4x4 &rhs)
  91. {
  92.     for (int i=0; i<16; ++i)
  93.         if (lhs.v[i] != rhs.v[i])
  94.             return false;
  95.     return true;
  96. }
  98. __forceinline bool operator!=(const Matrix4x4 &lhs, const Matrix4x4 &rhs)
  99. {
  100.     return !(lhs == rhs);
  101. }
  103. // Methods
  105. __forceinline void set_to_zero_matrix(Matrix4x4 &m)
  106. {
  107.     m.v[xx]=m.v[xy]=m.v[xz]=m.v[xw]=0.f;
  108.     m.v[yx]=m.v[yy]=m.v[yz]=m.v[yw]=0.f;
  109.     m.v[zx]=m.v[zy]=m.v[zz]=m.v[zw]=0.f;
  110.     m.v[tx]=m.v[ty]=m.v[tz]=m.v[tw]=0.f;
  111. }
  113. __forceinline void set_to_identity_matrix(Matrix4x4 &m)
  114. {
  115.     m = matrix4x4_identity();
  116. }
  118. __forceinline const Matrix4x4 &matrix4x4_zero()
  119. {
  120.     static Matrix4x4 zero = {{
  121.         0.f, 0.f, 0.f, 0.f,
  122.         0.f, 0.f, 0.f, 0.f,
  123.         0.f, 0.f, 0.f, 0.f,
  124.         0.f, 0.f, 0.f, 0.f
  125.     }};
  126.     return zero;
  127. }
  129. __forceinline const Matrix4x4 &matrix4x4_identity()
  130. {
  131.     static Matrix4x4 id = {{
  132.         1.f, 0.f, 0.f, 0.f,
  133.         0.f, 1.f, 0.f, 0.f,
  134.         0.f, 0.f, 1.f, 0.f,
  135.         0.f, 0.f, 0.f, 1.f
  136.     }};
  137.     return id;
  138. }
  140. __forceinline void set_to_scale_matrix(Matrix4x4 &m, const Vector3 &s)
  141. {
  142.     set_to_identity_matrix(m);
  143.     m.v[xx] = s.x;
  144.     m.v[yy] = s.y;
  145.     m.v[zz] = s.z;
  146. }
  148. __forceinline void set_to_translation_matrix(Matrix4x4 &m, const Vector3 &t)
  149. {
  150.     set_to_identity_matrix(m);
  151.     m.v[tx] = t.x;
  152.     m.v[ty] = t.y;
  153.     m.v[tz] = t.z;
  154. }
  156. __forceinline void normalize(Matrix4x4 &m) {
  157.     Vector3 &x = x_axis(m);
  158.     Vector3 &y = y_axis(m);
  159.     Vector3 &z = z_axis(m);
  161.     x = normalize(x);
  162.     y -= x*dot(x, y);
  163.     y = normalize(y);
  164.     z = cross(x,y);
  165. }
  167. __forceinline float determinant(const Matrix4x4 &m) {
  168. //  return m.v[xx]*m.v[yy]*m.v[zz] + m.v[xy]*m.v[yz]*m.v[zx] + m.v[xz]*m.v[yx]*m.v[zy] -
  169. //      m.v[xz]*m.v[yy]*m.v[zx] - m.v[xy]*m.v[yx]*m.v[zz] - m.v[xx]*m.v[yz]*m.v[zy];
  171.     return
  172.         m.v[3] * m.v[6] * m.v[ 9] * m.v[12] - m.v[2] * m.v[7] * m.v[ 9] * m.v[12] - m.v[3] * m.v[5] * m.v[10] * m.v[12] + m.v[1] * m.v[7] * m.v[10] * m.v[12] +
  173.         m.v[2] * m.v[5] * m.v[11] * m.v[12] - m.v[1] * m.v[6] * m.v[11] * m.v[12] - m.v[3] * m.v[6] * m.v[ 8] * m.v[13] + m.v[2] * m.v[7] * m.v[ 8] * m.v[13] +
  174.         m.v[3] * m.v[4] * m.v[10] * m.v[13] - m.v[0] * m.v[7] * m.v[10] * m.v[13] - m.v[2] * m.v[4] * m.v[11] * m.v[13] + m.v[0] * m.v[6] * m.v[11] * m.v[13] +
  175.         m.v[3] * m.v[5] * m.v[ 8] * m.v[14] - m.v[1] * m.v[7] * m.v[ 8] * m.v[14] - m.v[3] * m.v[4] * m.v[ 9] * m.v[14] + m.v[0] * m.v[7] * m.v[ 9] * m.v[14] +
  176.         m.v[1] * m.v[4] * m.v[11] * m.v[14] - m.v[0] * m.v[5] * m.v[11] * m.v[14] - m.v[2] * m.v[5] * m.v[ 8] * m.v[15] + m.v[1] * m.v[6] * m.v[ 8] * m.v[15] +
  177.         m.v[2] * m.v[4] * m.v[ 9] * m.v[15] - m.v[0] * m.v[6] * m.v[ 9] * m.v[15] - m.v[1] * m.v[4] * m.v[10] * m.v[15] + m.v[0] * m.v[5] * m.v[10] * m.v[15];
  179. }
  181. __forceinline bool has_mirroring(const Matrix4x4 &m) {
  182.     return (determinant(m) < 0.0f);
  183. }
  185. __forceinline float & element(Matrix4x4 &m, int i, int j)
  186. {
  187.     return m.v[i*4 + j];
  188. }
  190. __forceinline const float & element(const Matrix4x4 &m, int i, int j)
  191. {
  192.     return m.v[i*4 + j];
  193. }
  195. __forceinline void transpose(Matrix4x4 &m)
  196. {
  197.     #define SWAP(a,b) {float temp = a; a = b; b = temp;}
  199.     SWAP(m.v[1], m.v[4]);
  200.     SWAP(m.v[2], m.v[8]);
  201.     SWAP(m.v[3], m.v[12]);
  202.     SWAP(m.v[6], m.v[9]);
  203.     SWAP(m.v[7], m.v[13]);
  204.     SWAP(m.v[11], m.v[14]);
  206.     #undef SWAP
  207. }
  209. // Vector3 helper access
  210. __forceinline Vector3 &translation(Matrix4x4 &m) {
  211.     return *reinterpret_cast<Vector3 *>(&m.v[tx]);
  212. }
  213. __forceinline Vector3 &x_axis(Matrix4x4 &m) {
  214.     return *reinterpret_cast<Vector3 *>(&m.v[xx]);
  215. }
  216. __forceinline Vector3 &y_axis(Matrix4x4 &m) {
  217.     return *reinterpret_cast<Vector3 *>(&m.v[yx]);
  218. }
  219. __forceinline Vector3 &z_axis(Matrix4x4 &m) {
  220.     return *reinterpret_cast<Vector3 *>(&m.v[zx]);
  221. }
  223. __forceinline const Vector3 &translation(const Matrix4x4 &m) {
  224.     return *reinterpret_cast<const Vector3 *>(&m.v[tx]);
  225. }
  226. __forceinline const Vector3 &x_axis(const Matrix4x4 &m){
  227.     return *reinterpret_cast<const Vector3 *>(&m.v[xx]);
  228. }
  229. __forceinline const Vector3 &y_axis(const Matrix4x4 &m){
  230.     return *reinterpret_cast<const Vector3 *>(&m.v[yx]);
  231. }
  232. __forceinline const Vector3 &z_axis(const Matrix4x4 &m){
  233.     return *reinterpret_cast<const Vector3 *>(&m.v[zx]);
  234. }
  236. __forceinline Vector3 &forward_axis(Matrix4x4 &m) {
  237.     return y_axis(m);
  238. }
  239. __forceinline Vector3 &up_axis(Matrix4x4 &m) {
  240.     return z_axis(m);
  241. }
  242. __forceinline Vector3 &right_axis(Matrix4x4 &m) {
  243.     return x_axis(m);
  244. }
  246. __forceinline const Vector3 &forward_axis(const Matrix4x4 &m){
  247.     return y_axis(m);
  248. }
  249. __forceinline const Vector3 &up_axis(const Matrix4x4 &m){
  250.     return z_axis(m);
  251. }
  252. __forceinline const Vector3 &right_axis(const Matrix4x4 &m){
  253.     return x_axis(m);
  254. }
  256. __forceinline Vector3 &axis(Matrix4x4 &m, int i)
  257. {
  258.     return *reinterpret_cast<Vector3 *>(&m.v[xx] + i*4);
  259. }
  261. __forceinline const Vector3 &axis(const Matrix4x4 &m, int i)
  262. {
  263.     return *reinterpret_cast<const Vector3 *>(&m.v[xx] + i*4);
  264. }
  266. __forceinline Vector4 &row(Matrix4x4 &m, int i)
  267. {
  268.     return *reinterpret_cast<Vector4 *>(&m.v[xx] + i*4);
  269. }
  271. __forceinline const Vector4 &row(const Matrix4x4 &m, int i)
  272. {
  273.     return *reinterpret_cast<const Vector4 *>(&m.v[xx] + i*4);
  274. }
  276. __forceinline void set_translation(Matrix4x4 &m, const Vector3 &t)
  277. {
  278.     translation(m) = t;
  279. }
  281. __forceinline Vector3 transform(const Matrix4x4 &m, const Vector3 &p)
  282. {
  283.     Vector3 pt;
  284.     pt.x = m.v[xx] * p.x + m.v[yx] * p.y + m.v[zx] * p.z + m.v[tx];
  285.     pt.y = m.v[xy] * p.x + m.v[yy] * p.y + m.v[zy] * p.z + m.v[ty];
  286.     pt.z = m.v[xz] * p.x + m.v[yz] * p.y + m.v[zz] * p.z + m.v[tz];
  287.     return pt;
  288. }
  290. __forceinline Vector3 transform_without_translation(const Matrix4x4 &m, const Vector3 &p)
  291. {
  292.     Vector3 pt;
  293.     pt.x = m.v[xx] * p.x + m.v[yx] * p.y + m.v[zx] * p.z;
  294.     pt.y = m.v[xy] * p.x + m.v[yy] * p.y + m.v[zy] * p.z;
  295.     pt.z = m.v[xz] * p.x + m.v[yz] * p.y + m.v[zz] * p.z;
  296.     return pt;
  297. }
  299. __forceinline Vector4 transform(const Matrix4x4 &m, const Vector4 &p)
  300. {
  301.     Vector4 pt;
  302.     pt.x = m.v[xx] * p.x + m.v[yx] * p.y + m.v[zx] * p.z + p.w * m.v[tx];
  303.     pt.y = m.v[xy] * p.x + m.v[yy] * p.y + m.v[zy] * p.z + p.w * m.v[ty];
  304.     pt.z = m.v[xz] * p.x + m.v[yz] * p.y + m.v[zz] * p.z + p.w * m.v[tz];
  305.     pt.w = m.v[xw] * p.x + m.v[yw] * p.y + m.v[zw] * p.z + p.w * m.v[tw];
  306.     return pt;
  307. }
  309. __forceinline Matrix4x4 rotation(const Matrix4x4 &m)
  310. {
  311.     Matrix4x4 out = m;
  312.     out.v[xw] = out.v[yw] = out.v[zw] = out.v[tx] = out.v[ty] = out.v[tz] = 0;
  313.     out.v[tw] = 1;
  314.     return out;
  315. }
  317. __forceinline void set_rotation(Matrix4x4 &m, const Matrix4x4 &rot)
  318. {
  319.     x_axis(m) = x_axis(rot);
  320.     y_axis(m) = y_axis(rot);
  321.     z_axis(m) = z_axis(rot);
  322. }
  324. __forceinline Vector3 scale(const Matrix4x4 &m)
  325. {
  326.     Vector3 s;
  327.     s.x = length(x_axis(m));
  328.     s.y = length(y_axis(m));
  329.     s.z = length(z_axis(m));
  330.     return s;
  331. }
  333. __forceinline void set_scale(Matrix4x4 &m, const Vector3 &s)
  334. {
  335.     Vector3 p = scale(m);
  336.     x_axis(m) *= s.x / p.x;
  337.     y_axis(m) *= s.y / p.y;
  338.     z_axis(m) *= s.z / p.z;
  339. }
  341. inline Matrix4x4 inverse(const Matrix4x4 &m)
  342. {
  343.     Matrix4x4 inv = matrix4x4_identity();
  344.     Matrix4x4 temp = m;
  345.     int i, j, k, swap;
  346.     float *v = (float *)&temp.v[xx];
  347.     float *v2 = (float *)&inv.v[xx];
  348.     for(i=0; i!=4; ++i) {
  349.         swap=i;
  350.         for(j=i+1; j!=4; ++j) {
  351.             if(fabs(v[(j<<2)+i]) > fabs(v[(swap<<2)+i]))
  352.                 swap = j;
  353.         }
  354.         if (swap != i) {
  355.             for(k=0; k!=4; ++k) {
  356.                 const float t = v[(i<<2)+k];
  357.                 v[(i<<2)+k] = v[(swap<<2)+k];
  358.                 v[(swap<<2)+k] = t;
  360.                 const float t2 = v2[(i<<2)+k];
  361.                 v2[(i<<2)+k] = v2[(swap<<2)+k];
  362.                 v2[(swap<<2)+k] = t2;
  363.             }
  364.         }
  365.         if (v[(i<<2)+i] == 0)
  366.             return inv;
  367.         const float t = v[(i<<2)+i];
  368.         for (k=0; k!=4; ++k) {
  369.             v[(i<<2)+k] /= t;
  370.             v2[(i<<2)+k] /= t;
  371.         }
  372.         for (j=0; j!=4; ++j) {
  373.             if(j!=i) {
  374.                 const float t = v[(j<<2)+i];
  375.                 for(k=0; k<4; k++) {
  376.                     v[(j<<2)+k] -= v[(i<<2)+k]*t;
  377.                     v2[(j<<2)+k] -= v2[(i<<2)+k]*t;
  378.                 }
  379.             }
  380.         }
  381.     }
  382.     return inv;
  383. }
  385. }
Please send us your comment about this page