BVB Source Codes

CRYENGINE Show VMath_C.hpp Source code

Return Download CRYENGINE: download VMath_C.hpp Source code - Download CRYENGINE Source code - Type:.hpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  Version:     v1.00
  5. //  Created:     Michael Kopietz
  6. //  Description: unified vector math lib
  7. // -------------------------------------------------------------------------
  8. //  History:            - created 1999  for Katmai and K3
  9. //                                                      -       ...
  10. //                                                      -       integrated into cryengine
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13. #pragma once
  14.  
  15. namespace NVMath
  16. {
  17.  
  18. union vec4
  19. {
  20.         struct
  21.         {
  22.                 float m_Xf;
  23.                 float m_Yf;
  24.                 float m_Zf;
  25.                 float m_Wf;
  26.         };
  27.         struct
  28.         {
  29.                 uint32 m_Xu;
  30.                 uint32 m_Yu;
  31.                 uint32 m_Zu;
  32.                 uint32 m_Wu;
  33.         };
  34.         struct
  35.         {
  36.                 int32 m_Xs;
  37.                 int32 m_Ys;
  38.                 int32 m_Zs;
  39.                 int32 m_Ws;
  40.         };
  41.         float  m_f[4];
  42.         int32  m_s[4];
  43.         uint32 m_u[4];
  44. };
  45.  
  46. #include "VMath_Prototypes.hpp"
  47.  
  48. #define SWIZZLEMASK5(X, Y, Z, W) ((X) | (Y << 2) | (Z << 4) | (W << 6))
  49. #define SWIZZLEMASK4(N, X, Y, Z) N ## x = SWIZZLEMASK5(X, Y, Z, 0), \
  50.   N ## y = SWIZZLEMASK5(X, Y, Z, 1),                                \
  51.   N ## z = SWIZZLEMASK5(X, Y, Z, 2),                                \
  52.   N ## w = SWIZZLEMASK5(X, Y, Z, 3),
  53. #define SWIZZLEMASK3(N, X, Y)    SWIZZLEMASK4(N ## x, X, Y, 0) \
  54.   SWIZZLEMASK4(N ## y, X, Y, 1)                                \
  55.   SWIZZLEMASK4(N ## z, X, Y, 2)                                \
  56.   SWIZZLEMASK4(N ## w, X, Y, 3)
  57. #define SWIZZLEMASK2(N, X)       SWIZZLEMASK3(N ## x, X, 0) \
  58.   SWIZZLEMASK3(N ## y, X, 1)                                \
  59.   SWIZZLEMASK3(N ## z, X, 2)                                \
  60.   SWIZZLEMASK3(N ## w, X, 3)
  61. #define SWIZZLEMASK1 SWIZZLEMASK2(x, 0) \
  62.   SWIZZLEMASK2(y, 1)                    \
  63.   SWIZZLEMASK2(z, 2)                    \
  64.   SWIZZLEMASK2(w, 3)
  65.  
  66. enum ESwizzleMask
  67. {
  68.         SWIZZLEMASK1
  69. };
  70. enum ECacheLvl
  71. {
  72.         ECL_LVL1,
  73.         ECL_LVL2,
  74.         ECL_LVL3,
  75. };
  76. #define BitX 1
  77. #define BitY 2
  78. #define BitZ 4
  79. #define BitW 8
  80.  
  81. ILINE vec4 Vec4(float x, float y, float z, float w)
  82. {
  83.         vec4 Ret;
  84.         Ret.m_Xf = x;
  85.         Ret.m_Yf = y;
  86.         Ret.m_Zf = z;
  87.         Ret.m_Wf = w;
  88.         return Ret;
  89. }
  90. ILINE vec4 Vec4(uint32 x, uint32 y, uint32 z, uint32 w)
  91. {
  92.         vec4 Ret;
  93.         Ret.m_Xu = x;
  94.         Ret.m_Yu = y;
  95.         Ret.m_Zu = z;
  96.         Ret.m_Wu = w;
  97.         return Ret;
  98. }
  99. ILINE vec4 Vec4(float x)
  100. {
  101.         return Vec4(x, x, x, x);
  102. }
  103. ILINE float Vec4float(vec4 V, uint32 Idx)
  104. {
  105.         return V.m_f[Idx];
  106. }
  107. template<int Idx>
  108. ILINE float Vec4float(vec4 V)
  109. {
  110.         return Vec4float(V, Idx);
  111. }
  112. ILINE int32 Vec4int32(vec4 V, uint32 Idx)
  113. {
  114.         return V.m_s[Idx];
  115. }
  116. template<int Idx>
  117. ILINE int32 Vec4int32(vec4 V)
  118. {
  119.         return Vec4int32(V, Idx);
  120. }
  121. ILINE vec4 Vec4Zero()
  122. {
  123.         return Vec4(0.f);
  124. }
  125.  
  126. ILINE vec4 Vec4One()
  127. {
  128.         return Vec4(1.f, 1.f, 1.f, 1.f);
  129. }
  130. ILINE vec4 Vec4Four()
  131. {
  132.         return Vec4(4.f, 4.f, 4.f, 4.f);
  133. }
  134. ILINE vec4 Vec4ZeroOneTwoThree()
  135. {
  136.         return Vec4(0.f, 1.f, 2.f, 3.f);
  137. }
  138. ILINE vec4 Vec4FFFFFFFF()
  139. {
  140.         return Vec4(~0u, ~0u, ~0u, ~0u);
  141. }
  142. ILINE vec4 Vec4Epsilon()
  143. {
  144.         return Vec4(FLT_EPSILON);
  145. }
  146. template<ECacheLvl L>
  147. ILINE void Prefetch(const void* pData)
  148. {
  149. }
  150. template<ESwizzleMask M>
  151. ILINE vec4 Shuffle(vec4 V0, vec4 V1)
  152. {
  153.         return Vec4(V0.m_u[M & 3], V0.m_u[(M >> 2) & 3], V1.m_u[(M >> 4) & 3], V1.m_u[(M >> 6) & 3]);
  154. }
  155. template<ESwizzleMask M>
  156. ILINE vec4 Swizzle(vec4 V)
  157. {
  158.         return Shuffle<M>(V, V);
  159. }
  160. template<int INDEX>
  161. ILINE vec4 Splat(vec4 V)
  162. {
  163.         CRY_ASSERT_MESSAGE(0, "Should not be reached!");
  164.         return Vec4FFFFFFFF();
  165. }
  166. template<>
  167. ILINE vec4 Splat<0>(vec4 V)
  168. {
  169.         return Shuffle<xxxx>(V, V);
  170. }
  171. template<>
  172. ILINE vec4 Splat<1>(vec4 V)
  173. {
  174.         return Shuffle<yyyy>(V, V);
  175. }
  176. template<>
  177. ILINE vec4 Splat<2>(vec4 V)
  178. {
  179.         return Shuffle<zzzz>(V, V);
  180. }
  181. template<>
  182. ILINE vec4 Splat<3>(vec4 V)
  183. {
  184.         return Shuffle<wwww>(V, V);
  185. }
  186. ILINE vec4 Add(vec4 V0, vec4 V1)
  187. {
  188.         return Vec4(V0.m_Xf + V1.m_Xf,
  189.                     V0.m_Yf + V1.m_Yf,
  190.                     V0.m_Zf + V1.m_Zf,
  191.                     V0.m_Wf + V1.m_Wf);
  192. }
  193. ILINE vec4 Sub(vec4 V0, vec4 V1)
  194. {
  195.         return Vec4(V0.m_Xf - V1.m_Xf,
  196.                     V0.m_Yf - V1.m_Yf,
  197.                     V0.m_Zf - V1.m_Zf,
  198.                     V0.m_Wf - V1.m_Wf);
  199. }
  200. ILINE vec4 Mul(vec4 V0, vec4 V1)
  201. {
  202.         return Vec4(V0.m_Xf * V1.m_Xf,
  203.                     V0.m_Yf * V1.m_Yf,
  204.                     V0.m_Zf * V1.m_Zf,
  205.                     V0.m_Wf * V1.m_Wf);
  206. }
  207. ILINE vec4 Div(vec4 V0, vec4 V1)
  208. {
  209.         return Vec4(V0.m_Xf / V1.m_Xf,
  210.                     V0.m_Yf / V1.m_Yf,
  211.                     V0.m_Zf / V1.m_Zf,
  212.                     V0.m_Wf / V1.m_Wf);
  213. }
  214. ILINE vec4 RcpFAST(vec4 V)
  215. {
  216.         return Div(Vec4One(), V);
  217. }
  218. ILINE vec4 DivFAST(vec4 V0, vec4 V1)
  219. {
  220.         return Div(V0, V1);
  221. }
  222. ILINE vec4 Rcp(vec4 V)
  223. {
  224.         return Div(Vec4One(), V);
  225. }
  226. ILINE vec4 Madd(vec4 V0, vec4 V1, vec4 V2)
  227. {
  228.         return Add(V2, Mul(V0, V1));
  229. }
  230. ILINE vec4 Msub(vec4 V0, vec4 V1, vec4 V2)
  231. {
  232.         return Sub(Mul(V0, V1), V2);
  233. }
  234. ILINE vec4 Min(vec4 V0, vec4 V1)
  235. {
  236.         return Vec4(V0.m_Xf < V1.m_Xf ? V0.m_Xf : V1.m_Xf,
  237.                     V0.m_Yf < V1.m_Yf ? V0.m_Yf : V1.m_Yf,
  238.                     V0.m_Zf < V1.m_Zf ? V0.m_Zf : V1.m_Zf,
  239.                     V0.m_Wf < V1.m_Wf ? V0.m_Wf : V1.m_Wf);
  240. }
  241. ILINE vec4 Max(vec4 V0, vec4 V1)
  242. {
  243.         return Vec4(V0.m_Xf > V1.m_Xf ? V0.m_Xf : V1.m_Xf,
  244.                     V0.m_Yf > V1.m_Yf ? V0.m_Yf : V1.m_Yf,
  245.                     V0.m_Zf > V1.m_Zf ? V0.m_Zf : V1.m_Zf,
  246.                     V0.m_Wf > V1.m_Wf ? V0.m_Wf : V1.m_Wf);
  247. }
  248. ILINE vec4 floatToint32(vec4 V)
  249. {
  250.         return Vec4(static_cast<uint32>(static_cast<int32>(V.m_Xf)),
  251.                     static_cast<uint32>(static_cast<int32>(V.m_Yf)),
  252.                     static_cast<uint32>(static_cast<int32>(V.m_Zf)),
  253.                     static_cast<uint32>(static_cast<int32>(V.m_Wf)));
  254. }
  255. ILINE vec4 int32Tofloat(vec4 V)
  256. {
  257.         return Vec4(static_cast<float>(V.m_Xs),
  258.                     static_cast<float>(V.m_Ys),
  259.                     static_cast<float>(V.m_Zs),
  260.                     static_cast<float>(V.m_Ws));
  261. }
  262. ILINE vec4 CmpLE(vec4 V0, vec4 V1)
  263. {
  264.         return Vec4(V0.m_Xf <= V1.m_Xf ? ~0u : 0u,
  265.                     V0.m_Yf <= V1.m_Yf ? ~0u : 0u,
  266.                     V0.m_Zf <= V1.m_Zf ? ~0u : 0u,
  267.                     V0.m_Wf <= V1.m_Wf ? ~0u : 0u);
  268. }
  269. ILINE uint32 SignMask(vec4 V)
  270. {
  271.         return (V.m_Xu >> 31) | ((V.m_Yu >> 31) << 1) | ((V.m_Zu >> 31) << 2) | ((V.m_Wu >> 31) << 3);
  272. }
  273. ILINE vec4 And(vec4 V0, vec4 V1)
  274. {
  275.         return Vec4(V0.m_Xu & V1.m_Xu,
  276.                     V0.m_Yu & V1.m_Yu,
  277.                     V0.m_Zu & V1.m_Zu,
  278.                     V0.m_Wu & V1.m_Wu);
  279. }
  280. ILINE vec4 AndNot(vec4 V0, vec4 V1)
  281. {
  282.         return Vec4((~V0.m_Xu) & V1.m_Xu,
  283.                     (~V0.m_Yu) & V1.m_Yu,
  284.                     (~V0.m_Zu) & V1.m_Zu,
  285.                     (~V0.m_Wu) & V1.m_Wu);
  286. }
  287. ILINE vec4 Or(vec4 V0, vec4 V1)
  288. {
  289.         return Vec4(V0.m_Xu | V1.m_Xu,
  290.                     V0.m_Yu | V1.m_Yu,
  291.                     V0.m_Zu | V1.m_Zu,
  292.                     V0.m_Wu | V1.m_Wu);
  293. }
  294. ILINE vec4 Xor(vec4 V0, vec4 V1)
  295. {
  296.         return Vec4(V0.m_Xu ^ V1.m_Xu,
  297.                     V0.m_Yu ^ V1.m_Yu,
  298.                     V0.m_Zu ^ V1.m_Zu,
  299.                     V0.m_Wu ^ V1.m_Wu);
  300. }
  301. ILINE vec4 Select(vec4 V0, vec4 V1, vec4 M)
  302. {
  303.         return SelectSign(V0, V1, M);
  304. }
  305. ILINE vec4 ShiftAR(vec4 V, uint32 Count)
  306. {
  307.         return Vec4(static_cast<uint32>(V.m_Xs >> Count),
  308.                     static_cast<uint32>(V.m_Ys >> Count),
  309.                     static_cast<uint32>(V.m_Zs >> Count),
  310.                     static_cast<uint32>(V.m_Ws >> Count));
  311. }
  312. ILINE vec4 SelectSign(vec4 V0, vec4 V1, vec4 M)
  313. {
  314.         M = ShiftAR(M, 31);
  315.         return Or(AndNot(M, V0), And(M, V1));
  316. }
  317. template<int M>
  318. ILINE vec4 SelectStatic(vec4 V0, vec4 V1)
  319. {
  320.         const vec4 mask = NVMath::Vec4(M & 0x1 ? ~0x0u : 0x0u, M & 0x2 ? ~0x0u : 0x0u, M & 0x4 ? ~0x0u : 0x0u, M & 0x8 ? ~0x0u : 0x0u);
  321.         return Select(V0, V1, mask);
  322. }
  323.  
  324. ILINE vec4 SelectBits(vec4 V0, vec4 V1, vec4 M)
  325. {
  326.         return Or(AndNot(M, V0), And(M, V1));
  327. }
  328.  
  329. ILINE vec4 CmpEq(vec4 V0, vec4 V1)
  330. {
  331.         return Vec4(
  332.           V0.m_Xs == V1.m_Xs ? 0xffffffff : 0x0,
  333.           V0.m_Ys == V1.m_Ys ? 0xffffffff : 0x0,
  334.           V0.m_Zs == V1.m_Zs ? 0xffffffff : 0x0,
  335.           V0.m_Ws == V1.m_Ws ? 0xffffffff : 0x0);
  336. }
  337.  
  338. ILINE void ExtractByteToFloat(vec4& rVOut0, vec4& rVOut1, vec4& rVOut2, vec4& rVOut3, vec4 VIn)
  339. {
  340.         const char* const VInBytes = (const char*)&VIn;
  341.         vec4 VOutVecs[4];
  342.         int* VOutInts[4] =
  343.         {
  344.                 reinterpret_cast<int*>(&VOutVecs[0]),
  345.                 reinterpret_cast<int*>(&VOutVecs[1]),
  346.                 reinterpret_cast<int*>(&VOutVecs[2]),
  347.                 reinterpret_cast<int*>(&VOutVecs[3])
  348.         };
  349.  
  350.         VOutInts[0][0] = VInBytes[0];
  351.         VOutInts[0][1] = VInBytes[1];
  352.         VOutInts[0][2] = VInBytes[2];
  353.         VOutInts[0][3] = VInBytes[3];
  354.         VOutInts[1][0] = VInBytes[4];
  355.         VOutInts[1][1] = VInBytes[5];
  356.         VOutInts[1][2] = VInBytes[6];
  357.         VOutInts[1][3] = VInBytes[7];
  358.         VOutInts[2][0] = VInBytes[8];
  359.         VOutInts[2][1] = VInBytes[9];
  360.         VOutInts[2][2] = VInBytes[10];
  361.         VOutInts[2][3] = VInBytes[11];
  362.         VOutInts[3][0] = VInBytes[12];
  363.         VOutInts[3][1] = VInBytes[13];
  364.         VOutInts[3][2] = VInBytes[14];
  365.         VOutInts[3][3] = VInBytes[15];
  366.  
  367.         rVOut0 = int32Tofloat(VOutVecs[0]);
  368.         rVOut1 = int32Tofloat(VOutVecs[1]);
  369.         rVOut2 = int32Tofloat(VOutVecs[2]);
  370.         rVOut3 = int32Tofloat(VOutVecs[3]);
  371. }
  372.  
  373. }
  374.  
downloadVMath_C.hpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top