API tools faq
paste
Guest User

Untitled

a guest
Sep 10th, 2017
256
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.83 KB | None | 0 0
raw download clone embed print report
  1. #pragma once
  2.  
  3. const double PI = 3.1416;          
  4. const double DEGREE = 180.0 / PI;  
  5.  
  6.  
  7. #include <windows.h>
  8. #include <WinNT.h>
  9. #include "zstring.h"
  10.  
  11.  
  12. inline int zFloat2Int (const float f)
  13. {
  14.     int i;
  15.     __asm fld [f]
  16.     __asm fistp [i]
  17.     return i;
  18. }
  19.  
  20. inline void zClamp(int& value, int bl, int bh)
  21. {
  22.     if(value < bl)
  23.         value = bl;
  24.     else if(value > bh)
  25.         value = bh;
  26. }
  27.  
  28.  
  29. inline void zClamp(float& value, float bl, float bh)
  30. {
  31.     if(value < bl)
  32.         value = bl;
  33.     else if(value > bh)
  34.         value = bh;
  35. }
  36.  
  37.  
  38. class zVEC2            
  39. {
  40. public:
  41.     float       n[2];
  42. public:
  43.     zVEC2();
  44.    
  45.     zVEC2(float, float);
  46.     zVEC2& operator+=(zVEC2 const&);
  47.     zVEC2& operator-=(zVEC2 const&);
  48.     zVEC2& operator*=(float);
  49.     float& operator[](int);
  50.     const float& operator[](int) const;
  51.     zVEC2& operator/=(float);
  52.    
  53.     float Length2();
  54.    
  55.     zVEC2& Apply(float (*)(float));
  56.     zSTRING GetDescription() const;
  57.     void SetByDescription(zSTRING const&);
  58. };
  59.  
  60.  
  61. inline float& zVEC2::operator[](int index)
  62. {
  63.     return n[index];
  64. }
  65.  
  66.  
  67. inline const float& zVEC2::operator[](int index) const
  68. {
  69.     return n[index];
  70. }
  71.  
  72.  
  73.  
  74.  
  75. float operator*(zVEC2 const&, zVEC2 const&);
  76.  
  77. zVEC2 operator+(zVEC2 const&, zVEC2 const&);
  78.  
  79. zVEC2 operator-(zVEC2 const&, zVEC2 const&);
  80.  
  81. zVEC2 operator*(zVEC2 const&, float);
  82.  
  83. zVEC2 operator/(zVEC2 const&, float);
  84.  
  85. zVEC2 operator-(zVEC2 const&);
  86.  
  87.  
  88.  
  89.  
  90. class zVEC3            
  91. {
  92. public:
  93.     float       n[3];
  94.     zVEC3();
  95.     zVEC3(float);
  96.     zVEC3(float, float, float);
  97.     zVEC3& operator-=(zVEC3 const&);
  98.     zVEC3& operator+=(zVEC3 const&);
  99.     zVEC3& operator*=(float);
  100.     zVEC3& operator/=(float);
  101.     float& operator[](int);
  102.     const float& operator[](int) const;
  103.     float Length2() const;
  104.     float Length() const;
  105.     float LengthApprox() const;
  106.     float Distance(const zVEC3&) const;
  107.     float DistanceAbs(const zVEC3&) const;
  108.     zVEC3& Normalize();
  109.     zVEC3& NormalizeSafe();
  110.     zVEC3& NormalizeApprox();
  111.     BOOL IsEqualEps(zVEC3 const&) const;
  112.    
  113.     zSTRING GetString(void)const;
  114.     void SetByDescription( const zSTRING& str );
  115.     zVEC3& Apply(float (*)(float));
  116.     float MultAbs(const zVEC3&) const;
  117.    
  118.     float GetX();
  119.     float GetY();
  120.     float GetZ();
  121.    
  122.     float Dot(const zVEC3& other) const
  123.     {
  124.         const zVEC3& va = *this;
  125.         const zVEC3& vb = other;
  126.         return va[0] * vb[0] + va[1] * vb[1] + va[2] * vb[2];
  127.     };
  128.  
  129.     zVEC3 Cross(const zVEC3& other) const
  130.     {
  131.         const zVEC3& va = *this;
  132.         const zVEC3& vb = other;
  133.         return zVEC3(va[1] * vb[2] - va[2] * vb[1],
  134.                      va[2] * vb[0] - va[0] * vb[2],
  135.                      va[0] * vb[1] - va[1] * vb[0]);
  136.     };
  137. };
  138.  
  139.  
  140. inline float& zVEC3::operator[](int index)
  141. {
  142.     return n[index];
  143. }
  144.  
  145.  
  146. inline const float& zVEC3::operator[](int index) const
  147. {
  148.     return n[index];
  149. }
  150.  
  151.  
  152. inline float zVEC3::Length2() const
  153. {
  154.     return n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
  155. }
  156.  
  157.  
  158. inline float zVEC3::Length() const
  159. {
  160.     return sqrt(Length2());
  161. }
  162.  
  163.  
  164.  
  165. BOOL operator==(zVEC3 const&, zVEC3 const&);
  166.  
  167. zVEC3 operator+(zVEC3 const&, zVEC3 const&);
  168.  
  169. zVEC3 operator-(zVEC3 const&, zVEC3 const&);
  170.  
  171. zVEC3 operator^(zVEC3 const&, zVEC3 const&);
  172.  
  173. zVEC3 operator*(zVEC3 const&, float);
  174.  
  175. zVEC3 operator/(zVEC3 const&, float);
  176.  
  177. float operator*(zVEC3 const&, zVEC3 const&);
  178.  
  179. zVEC3 operator-(zVEC3 const&);
  180.  
  181.  
  182.  
  183. inline float operator*(zVEC3 const& va, zVEC3 const& vb)
  184. {
  185.     return va[0] * vb[0] + va[1] * vb[1] + va[2] * vb[2];
  186. }
  187.  
  188.  
  189.  
  190. class zVEC4                
  191. {
  192. public:
  193.     float       n[4];
  194. public:
  195.     zVEC4();
  196.     zVEC4(float);
  197.     zVEC4(zVEC3 const&, float);
  198.     zVEC4(float, float, float, float);
  199.     zVEC4& operator+=(zVEC4 const&);
  200.     zVEC4& operator-=(zVEC4 const&);
  201.     zVEC4& operator*=(float);
  202.     float& operator[](int);
  203.     const float& operator[](int) const;
  204.     float Length2() const;
  205.     float LengthApprox() const;
  206.     zVEC4& Normalize();
  207.     zVEC4& Apply(float (*)(float));
  208. };
  209.  
  210.  
  211. inline float& zVEC4::operator[](int index)
  212. {
  213.     return n[index];
  214. }
  215.  
  216.  
  217. inline const float& zVEC4::operator[](int index) const
  218. {
  219.     return n[index];
  220. }
  221.  
  222.  
  223. inline float zVEC4::Length2() const
  224. {
  225.     return n[0] * n[0] + n[1] * n[1] + n[2] * n[2] + n[3] * n[3];
  226. }
  227.  
  228.  
  229. BOOL operator==(zVEC4 const&, zVEC4 const&);
  230.  
  231. zVEC4 operator*(zVEC4 const&, float);
  232.  
  233. float operator*(zVEC4 const&, zVEC4 const&);
  234.  
  235. zVEC4 operator+(zVEC4 const&, zVEC4 const&);
  236.  
  237. zVEC4 operator-(zVEC4 const&, zVEC4 const&);
  238.  
  239. zVEC4 operator-(zVEC4 const&);
  240.  
  241.  
  242. inline float operator*(zVEC4 const& va, zVEC4 const& vb)
  243. {
  244.     return va[0] * vb[0] + va[1] * vb[1] + va[2] * vb[2]  + va[3] * vb[3];
  245. }
  246.  
  247.  
  248. class zMAT3                
  249. {
  250.  
  251.     zVEC3       row[3];
  252.  
  253. public:
  254.     zMAT3() {};
  255.     zMAT3(zVEC3 const&, zVEC3 const&, zVEC3 const&);
  256.     zMAT3(float);
  257.     zMAT3& operator+=(zMAT3 const&);
  258.     zMAT3& operator-=(zMAT3 const&);
  259.     zMAT3& operator*=(float);
  260.     zMAT3& operator/=(float);
  261.     zVEC3& operator[](int);
  262.     const zVEC3& operator[](int) const;
  263.     zMAT3 Transpose() const;
  264.     zMAT3 Inverse(float*);
  265.     void SetAtVector(zVEC3 const&);
  266.     zVEC3 GetAtVector() const;
  267.     void SetUpVector(zVEC3 const&);
  268.     zVEC3 GetUpVector() const;
  269.     void SetRightVector(zVEC3 const&);
  270.     zVEC3 GetRightVector() const;
  271.     void MakeOrthonormal();
  272.     zMAT3& Apply(float (*)(float));
  273. };
  274.  
  275.  
  276. inline zVEC3& zMAT3::operator[](int index)
  277. {
  278.     return row[index];
  279. }
  280.  
  281.  
  282. inline const zVEC3& zMAT3::operator[](int index) const
  283. {
  284.     return row[index];
  285. }
  286.  
  287.  
  288. zMAT3 operator-(zMAT3 const&);
  289.  
  290. zMAT3 operator+(zMAT3 const&, zMAT3 const&);
  291.  
  292. zMAT3 operator-(zMAT3 const&, zMAT3 const&);
  293.  
  294. zMAT3 operator*(zMAT3 const&, zMAT3 const&);
  295.  
  296. zVEC3 operator*(zMAT3 const&, zVEC3 const&);
  297.  
  298. zVEC2 operator*(zMAT3 const&, zVEC2 const&);
  299.  
  300. zMAT3 operator*(zMAT3 const&, float);
  301.  
  302. zMAT3 operator*(float, zMAT3 const&);
  303.  
  304. zMAT3 operator/(zMAT3 const&, float);
  305.  
  306. BOOL operator==(zMAT3 const&, zMAT3 const&);
  307.  
  308. BOOL operator!=(zMAT3 const&, zMAT3 const&);
  309.  
  310.  
  311.  
  312. class zMAT4            
  313. {
  314. public:
  315.     zVEC4       row[4];
  316.    
  317. public:
  318.     zMAT4() {};
  319.     zMAT4(zVEC4 const&, zVEC4 const&, zVEC4 const&, zVEC4 const&);
  320.     zMAT4(float);
  321.     zMAT4& operator+=(zMAT4 const&);
  322.     zMAT4& operator-=(zMAT4 const&);
  323.     zMAT4& operator*=(float);
  324.     zMAT4& operator/=(float);
  325.     zVEC4& operator[](int);
  326.     const zVEC4& operator[](int) const;
  327.     zMAT4 Transpose() const;
  328.     zMAT4 Inverse() const;
  329.     zMAT4 InverseLinTrafo() const;
  330.     zMAT4& Translate(zVEC3 const&);
  331.     zMAT4& SetTranslation(zVEC3 const&);
  332.     zVEC3 GetTranslation() const;
  333.     void GetTranslation(zVEC3&) const;
  334.     void SetAtVector(zVEC3 const&);
  335.     zVEC3 GetAtVector() const;
  336.     void SetUpVector(zVEC3 const&);
  337.     zVEC3 GetUpVector() const;
  338.     void SetRightVector(zVEC3 const&);
  339.     zVEC3 GetRightVector() const;
  340.     zVEC3 ExtractScaling() const;
  341.     zMAT3 ExtractRotation();
  342.     void MakeOrthonormal();
  343.     zVEC3 Rotate(zVEC3 const&) const;
  344.     void PostRotateX(float);
  345.     void PostRotateY(float);
  346.     void PostRotateZ(float);
  347.     void PostScale(zVEC3 const&);
  348.     void PreScale(zVEC3 const&);
  349.     zVEC3 GetEulerAngles() const;
  350.     void SetByEulerAngles(zVEC3);
  351.     BOOL IsUpper3x3Orthonormal() const;
  352.     zMAT4& Apply(float (*)(float));
  353. };
  354.  
  355.  
  356. inline zVEC4& zMAT4::operator[](int index)
  357. {
  358.     return row[index];
  359. }
  360.  
  361.  
  362. inline const zVEC4& zMAT4::operator[](int index) const
  363. {
  364.     return row[index];
  365. }
  366.  
  367.  
  368. zMAT4 operator-(zMAT4 const&);
  369.  
  370. zMAT4 operator+(zMAT4 const&, zMAT4 const&);
  371.  
  372. zMAT4 operator-(zMAT4 const&, zMAT4 const&);
  373.  
  374. zMAT4 operator*(zMAT4 const&, zMAT4 const&);
  375.  
  376. zVEC3 operator*(zMAT4 const&, zVEC3 const&);
  377.  
  378. zMAT4 operator*(zMAT4 const&, float);
  379.  
  380. zMAT4 operator*(float, zMAT4 const&);
  381.  
  382. zMAT4 operator/(zMAT4 const&, float);
  383.  
  384. BOOL operator==(zMAT4 const&, zMAT4 const&);
  385.  
  386. BOOL operator!=(zMAT4 const&, zMAT4 const&);
  387.  
  388.  
  389. class zCQuat           
  390. {
  391.     zVEC4       qt;
  392. public:
  393.     zCQuat() {};
  394.     float& operator[](int);
  395.     const float& operator[](int) const;
  396.     void Unit();
  397.     void QuatToMatrix3(zMAT3&) const;
  398.     void QuatToMatrix4(zMAT4&) const;
  399.     void Matrix3ToQuat(zMAT3 const&);
  400.     void Matrix4ToQuat(zMAT4 const&);
  401.     void QuatToEuler(zVEC3&) const;
  402.     void EulerToQuat(zVEC3 const&);
  403.     void QuatToAxisAngle(zVEC3&, float&) const;
  404.     void QuatToAngAxis(zVEC3&, float&) const;
  405.     void Slerp(float, zCQuat const&, zCQuat const&);
  406.     void Lerp(float, zCQuat const&, zCQuat const&);
  407.     void Squad(float, zCQuat const&, zCQuat const&, zCQuat const&, zCQuat const&);
  408. };
  409.  
  410.  
  411. inline const float& zCQuat::operator [](int nIndex) const
  412. {
  413.     return qt[nIndex];
  414. }
  415.  
  416.  
  417. inline float& zCQuat::operator [](int nIndex)
  418. {
  419.     return qt[nIndex];
  420. }
  421.  
  422.  
  423. inline zMAT4 Alg_Identity3D(void)
  424. {
  425.     XCALL(0x00517B50);
  426. };
  427.  
  428.  
  429.  
  430. static float Alg_AngleUnitRad(const zVEC3& va, const zVEC3& vb)
  431. {
  432.     float c = va * vb;
  433.     if(c > 1.0)
  434.         return 0;
  435.     if(c < -1.0)
  436.         return (float)PI;
  437.     return acos(c);
  438. }
  439.  
  440.  
  441.  
  442. static float Alg_AngleUnit(const zVEC3& va, const zVEC3& vb)
  443. {
  444.     return (float)(Alg_AngleUnitRad(va, vb) * DEGREE);
  445. }
  446.  
  447.  
  448. static float Alg_AngleRad(const zVEC3& va, const zVEC3& vb)
  449. {
  450.     zVEC3 va2 = va;
  451.     va2.NormalizeSafe();
  452.     zVEC3 vb2 = vb;
  453.     vb2.NormalizeSafe();
  454.     return (float)Alg_AngleUnitRad(va2, vb2);
  455. }
  456.  
  457.  
  458. static float Alg_Angle(const zVEC3& va, const zVEC3& vb)
  459. {
  460.     return (float)(Alg_AngleRad(va, vb) * DEGREE);
  461. }
  462.  
  463. #include "zmath.inl"
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!