ShootingGame/BasicMath.h

   1 //// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
   2 //// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
   3 //// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
   4 //// PARTICULAR PURPOSE.
   5 ////
   6 //// Copyright (c) Microsoft Corporation. All rights reserved
   7
   8 #pragma once
   9
  10 #define _USE_MATH_DEFINES
  11 #include <math.h>
  12
  13 // Common Constants
  14
  15 #define PI_F 3.1415927f
  16
  17 // Template Vector & Matrix Classes
  18
  19 template <class T> struct Vector2
  20 {
  21     union
  22     {
  23         struct
  24         {
  25             T x;
  26             T y;
  27         };
  28         struct
  29         {
  30             T r;
  31             T g;
  32         };
  33         struct
  34         {
  35             T u;
  36             T v;
  37         };
  38     };
  39
  40     T& operator[](unsigned int index)
  41     {
  42         return static_cast<T*>(this)[index];
  43     }
  44
  45     Vector2(T _x = 0, T _y = 0) : x(_x), y(_y) { }
  46 };
  47
  48 template <class T> struct Vector3
  49 {
  50     union
  51     {
  52         struct
  53         {
  54             T x;
  55             T y;
  56             T z;
  57         };
  58         struct
  59         {
  60             T r;
  61             T g;
  62             T b;
  63         };
  64         struct
  65         {
  66             T u;
  67             T v;
  68             T w;
  69         };
  70     };
  71
  72     T& operator[](unsigned int index)
  73     {
  74         return static_cast<T*>(this)[index];
  75     }
  76
  77     Vector3(T _x = 0, T _y = 0, T _z = 0) : x(_x), y(_y), z(_z) { }
  78 };
  79
  80 template <class T> struct Vector4
  81 {
  82     union
  83     {
  84         struct
  85         {
  86             T x;
  87             T y;
  88             T z;
  89             T w;
  90         };
  91         struct
  92         {
  93             T r;
  94             T g;
  95             T b;
  96             T a;
  97         };
  98     };
  99
 100     T& operator[](unsigned int index)
 101     {
 102         return static_cast<T*>(this)[index];
 103     }
 104
 105     Vector4(T _x = 0, T _y = 0, T _z = 0, T _w = 0) : x(_x), y(_y), z(_z), w(_w) { }
 106 };
 107
 108 template <class T> struct Matrix4x4
 109 {
 110     union
 111     {
 112         struct
 113         {
 114             T _11; T _12; T _13; T _14;
 115             T _21; T _22; T _23; T _24;
 116             T _31; T _32; T _33; T _34;
 117             T _41; T _42; T _43; T _44;
 118         };
 119         struct
 120         {
 121             T _m00; T _m01; T _m02; T _m03;
 122             T _m10; T _m11; T _m12; T _m13;
 123             T _m20; T _m21; T _m22; T _m23;
 124             T _m30; T _m31; T _m32; T _m33;
 125         };
 126     };
 127
 128     Matrix4x4(T value = 0)
 129     {
 130         _11 = _12 = _13 = _14 = value;
 131         _21 = _22 = _23 = _24 = value;
 132         _31 = _32 = _33 = _34 = value;
 133         _41 = _42 = _43 = _44 = value;
 134     }
 135
 136     Matrix4x4(
 137         T i11, T i12, T i13, T i14,
 138         T i21, T i22, T i23, T i24,
 139         T i31, T i32, T i33, T i34,
 140         T i41, T i42, T i43, T i44
 141         )
 142     {
 143         _11 = i11; _12 = i12; _13 = i13; _14 = i14;
 144         _21 = i21; _22 = i22; _23 = i23; _24 = i24;
 145         _31 = i31; _32 = i32; _33 = i33; _34 = i34;
 146         _41 = i41; _42 = i42; _43 = i43; _44 = i44;
 147     }
 148
 149     T* operator[](unsigned int index)
 150     {
 151         return &(reinterpret_cast<T*>(this)[index*4]);
 152     }
 153 };
 154
 155 // Template Vector Operations
 156
 157 template <class T>
 158 T dot(Vector2<T> a, Vector2<T> b)
 159 {
 160     return a.x * b.x + a.y * b.y;
 161 }
 162
 163 template <class T>
 164 T dot(Vector3<T> a, Vector3<T> b)
 165 {
 166     return a.x * b.x + a.y * b.y + a.z * b.z;
 167 }
 168
 169 template <class T>
 170 T dot(Vector4<T> a, Vector4<T> b)
 171 {
 172     return a.x * b.x + a.y * b.y + a.z * b.z + a.w + b.w;
 173 }
 174
 175 template <class T>
 176 T length(Vector2<T> a)
 177 {
 178     return sqrt(a.x * a.x + a.y * a.y);
 179 }
 180
 181 template <class T>
 182 T length(Vector3<T> a)
 183 {
 184     return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
 185 }
 186
 187 template <class T>
 188 T length(Vector4<T> a)
 189 {
 190     return sqrt(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w);
 191 }
 192
 193 template <class T>
 194 Vector3<T> cross(Vector3<T> a, Vector3<T> b)
 195 {
 196     return Vector3<T>((a.y*b.z)-(a.z*b.y), (a.z*b.x)-(a.x*b.z), (a.x*b.y)-(a.y*b.x));
 197 }
 198
 199 template <class T>
 200 Vector2<T> normalize(Vector2<T> a)
 201 {
 202     T len = length(a);
 203     return Vector2<T>(a.x / len, a.y / len);
 204 }
 205
 206 template <class T>
 207 Vector3<T> normalize(Vector3<T> a)
 208 {
 209     T len = length(a);
 210     return Vector3<T>(a.x / len, a.y / len, a.z / len);
 211 }
 212
 213 template <class T>
 214 Vector4<T> normalize(Vector4<T> a)
 215 {
 216     T len = length(a);
 217     return Vector4<T>(a.x / len, a.y / len, a.z / len, a.w / len);
 218 }
 219
 220 // Template Vector Operators
 221
 222 template <class T>
 223 Vector2<T> operator-(Vector2<T> a, Vector2<T> b)
 224 {
 225     return Vector2<T>(a.x - b.x, a.y - b.y);
 226 }
 227
 228 template <class T>
 229 Vector2<T> operator-(Vector2<T> a)
 230 {
 231     return Vector2<T>( -a.x, -a.y);
 232 }
 233
 234 template <class T>
 235 Vector3<T> operator-(Vector3<T> a, Vector3<T> b)
 236 {
 237     return Vector3<T>(a.x - b.x, a.y - b.y, a.z - b.z);
 238 }
 239
 240 template <class T>
 241 Vector3<T> operator-(Vector3<T> a)
 242 {
 243     return Vector3<T>( -a.x, -a.y, -a.z);
 244 }
 245
 246 template <class T>
 247 Vector4<T> operator-(Vector4<T> a, Vector4<T> b)
 248 {
 249     return Vector4<T>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
 250 }
 251
 252 template <class T>
 253 Vector4<T> operator-(Vector4<T> a)
 254 {
 255     return Vector4<T>( -a.x, -a.y, -a.z, -a.w);
 256 }
 257
 258 template <class T>
 259 Vector2<T> operator+(Vector2<T> a, Vector2<T> b)
 260 {
 261     return Vector2<T>(a.x + b.x, a.y + b.y);
 262 }
 263
 264 template <class T>
 265 Vector3<T> operator+(Vector3<T> a, Vector3<T> b)
 266 {
 267     return Vector3<T>(a.x + b.x, a.y + b.y, a.z + b.z);
 268 }
 269
 270 template <class T>
 271 Vector4<T> operator+(Vector4<T> a, Vector4<T> b)
 272 {
 273     return Vector4<T>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
 274 }
 275
 276 template <class T>
 277 Vector2<T> operator*(Vector2<T> a, T s)
 278 {
 279     return Vector2<T>(a.x * s, a.y * s);
 280 }
 281
 282 template <class T>
 283 Vector2<T> operator*(T s, Vector2<T> a)
 284 {
 285     return a * s;
 286 }
 287
 288 template <class T>
 289 Vector2<T> operator*(Vector2<T> a, Vector2<T> b)
 290 {
 291     return Vector2<T>(a.x * b.x, a.y * b.y);
 292 }
 293
 294 template <class T>
 295 Vector2<T> operator/(Vector2<T> a, T s)
 296 {
 297     return Vector2<T>(a.x / s, a.y / s);
 298 }
 299
 300 template <class T>
 301 Vector3<T> operator*(Vector3<T> a, T s)
 302 {
 303     return Vector3<T>(a.x * s, a.y * s, a.z * s);
 304 }
 305
 306 template <class T>
 307 Vector3<T> operator*(T s, Vector3<T> a)
 308 {
 309     return a * s;
 310 }
 311
 312 template <class T>
 313 Vector3<T> operator*(Vector3<T> a, Vector3<T> b)
 314 {
 315     return Vector3<T>(a.x * b.x, a.y * b.y, a.z * b.z);
 316 }
 317
 318 template <class T>
 319 Vector3<T> operator/(Vector3<T> a, T s)
 320 {
 321     return Vector3<T>(a.x / s, a.y / s, a.z / s);
 322 }
 323
 324 template <class T>
 325 Vector4<T> operator*(Vector4<T> a, T s)
 326 {
 327     return Vector4<T>(a.x * s, a.y * s, a.z * s, a.w * s);
 328 }
 329
 330 template <class T>
 331 Vector4<T> operator*(T s, Vector4<T> a)
 332 {
 333     return a * s;
 334 }
 335
 336 template <class T>
 337 Vector4<T> operator*(Vector4<T> a, Vector4<T> b)
 338 {
 339     return Vector4<T>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
 340 }
 341
 342 template <class T>
 343 Vector4<T> operator/(Vector4<T> a, T s)
 344 {
 345     return Vector4<T>(a.x / s, a.y / s, a.z / s, a.w / s);
 346 }
 347
 348
 349
 350 // Template Matrix Operations
 351
 352 template <class T>
 353 Matrix4x4<T> transpose(Matrix4x4<T> m)
 354 {
 355     return Matrix4x4<T>(
 356         m._11, m._21, m._31, m._41,
 357         m_.12, m._22, m._32, m._42,
 358         m._13, m._23, m._33, m._43,
 359         m._14, m._24, m._34, m._44
 360         );
 361 }
 362
 363 template <class T>
 364 Matrix4x4<T> mul(Matrix4x4<T> m1, Matrix4x4<T> m2)
 365 {
 366     Matrix4x4<T> mOut;
 367
 368     for (int i = 0; i < 4; i++)
 369     {
 370         for (int j = 0; j < 4; j++)
 371         {
 372             for (int k = 0; k < 4; k++)
 373             {
 374                 mOut[i][j] += m1[i][k] * m2[k][j];
 375             }
 376         }
 377     }
 378
 379     return mOut;
 380 }
 381
 382 // Common HLSL-compatible vector typedefs
 383
 384 typedef unsigned int uint;
 385
 386 typedef Vector2<float> float2;
 387 typedef Vector3<float> float3;
 388 typedef Vector4<float> float4;
 389
 390 typedef Matrix4x4<float> float4x4;
 391
 392 // Standard Matrix Intializers
 393
 394 inline float4x4 identity()
 395 {
 396     float4x4 mOut;
 397
 398     mOut._11 = 1.0f; mOut._12 = 0.0f; mOut._13 = 0.0f; mOut._14 = 0.0f;
 399     mOut._21 = 0.0f; mOut._22 = 1.0f; mOut._23 = 0.0f; mOut._24 = 0.0f;
 400     mOut._31 = 0.0f; mOut._32 = 0.0f; mOut._33 = 1.0f; mOut._34 = 0.0f;
 401     mOut._41 = 0.0f; mOut._42 = 0.0f; mOut._43 = 0.0f; mOut._44 = 1.0f;
 402
 403     return mOut;
 404 }
 405
 406 inline float4x4 translation(float x, float y, float z)
 407 {
 408     float4x4 mOut;
 409
 410     mOut._11 = 1.0f; mOut._12 = 0.0f; mOut._13 = 0.0f; mOut._14 = x;
 411     mOut._21 = 0.0f; mOut._22 = 1.0f; mOut._23 = 0.0f; mOut._24 = y;
 412     mOut._31 = 0.0f; mOut._32 = 0.0f; mOut._33 = 1.0f; mOut._34 = z;
 413     mOut._41 = 0.0f; mOut._42 = 0.0f; mOut._43 = 0.0f; mOut._44 = 1.0f;
 414
 415     return mOut;
 416 }
 417
 418 inline float4x4 scale(float x, float y, float z)
 419 {
 420     float4x4 mOut;
 421
 422     mOut._11 = x;    mOut._12 = 0.0f; mOut._13 = 0.0f; mOut._14 = 0.0f;
 423     mOut._21 = 0.0f; mOut._22 = y;    mOut._23 = 0.0f; mOut._24 = 0.0f;
 424     mOut._31 = 0.0f; mOut._32 = 0.0f; mOut._33 = z;    mOut._34 = 0.0f;
 425     mOut._41 = 0.0f; mOut._42 = 0.0f; mOut._43 = 0.0f; mOut._44 = 1.0f;
 426
 427     return mOut;
 428 }
 429
 430 inline float4x4 rotationX(float degreeX)
 431 {
 432     float angleInRadians = degreeX * (PI_F / 180.0f);
 433
 434     float sinAngle = sinf(angleInRadians);
 435     float cosAngle = cosf(angleInRadians);
 436
 437     float4x4 mOut;
 438
 439     mOut._11 = 1.0f; mOut._12 = 0.0f;     mOut._13 = 0.0f;      mOut._14 = 0.0f;
 440     mOut._21 = 0.0f; mOut._22 = cosAngle; mOut._23 = -sinAngle; mOut._24 = 0.0f;
 441     mOut._31 = 0.0f; mOut._32 = sinAngle; mOut._33 = cosAngle;  mOut._34 = 0.0f;
 442     mOut._41 = 0.0f; mOut._42 = 0.0f;     mOut._43 = 0.0f;      mOut._44 = 1.0f;
 443
 444     return mOut;
 445 }
 446
 447 inline float4x4 rotationY(float degreeY)
 448 {
 449     float angleInRadians = degreeY * (PI_F / 180.0f);
 450
 451     float sinAngle = sinf(angleInRadians);
 452     float cosAngle = cosf(angleInRadians);
 453
 454     float4x4 mOut;
 455
 456     mOut._11 = cosAngle;  mOut._12 = 0.0f; mOut._13 = sinAngle; mOut._14 = 0.0f;
 457     mOut._21 = 0.0f;      mOut._22 = 1.0f; mOut._23 = 0.0f;     mOut._24 = 0.0f;
 458     mOut._31 = -sinAngle; mOut._32 = 0.0f; mOut._33 = cosAngle; mOut._34 = 0.0f;
 459     mOut._41 = 0.0f;      mOut._42 = 0.0f; mOut._43 = 0.0f;     mOut._44 = 1.0f;
 460
 461     return mOut;
 462 }
 463
 464 inline float4x4 rotationZ(float degreeZ)
 465 {
 466     float angleInRadians = degreeZ * (PI_F / 180.0f);
 467
 468     float sinAngle = sinf(angleInRadians);
 469     float cosAngle = cosf(angleInRadians);
 470
 471     float4x4 mOut;
 472
 473     mOut._11 = cosAngle; mOut._12 = -sinAngle; mOut._13 = 0.0f; mOut._14 = 0.0f;
 474     mOut._21 = sinAngle; mOut._22 = cosAngle;  mOut._23 = 0.0f; mOut._24 = 0.0f;
 475     mOut._31 = 0.0f;     mOut._32 = 0.0f;      mOut._33 = 1.0f; mOut._34 = 0.0f;
 476     mOut._41 = 0.0f;     mOut._42 = 0.0f;      mOut._43 = 0.0f; mOut._44 = 1.0f;
 477
 478     return mOut;
 479 }
 480
 481 // 3D Rotation matrix for an arbitrary axis specified by x, y and z
 482 inline float4x4 rotationArbitrary(float3 axis, float degree)
 483 {
 484     axis = normalize(axis);
 485
 486     float angleInRadians = degree * (PI_F / 180.0f);
 487
 488     float sinAngle = sinf(angleInRadians);
 489     float cosAngle = cosf(angleInRadians);
 490     float oneMinusCosAngle = 1 - cosAngle;
 491
 492     float4x4 mOut;
 493
 494     mOut._11 = 1.0f + oneMinusCosAngle * (axis.x * axis.x - 1.0f);
 495     mOut._12 = axis.z * sinAngle + oneMinusCosAngle * axis.x * axis.y;
 496     mOut._13 = -axis.y * sinAngle + oneMinusCosAngle * axis.x * axis.z;
 497     mOut._41 = 0.0f;
 498
 499     mOut._21 = -axis.z * sinAngle + oneMinusCosAngle * axis.y * axis.x;
 500     mOut._22 = 1.0f + oneMinusCosAngle * (axis.y * axis.y - 1.0f);
 501     mOut._23 = axis.x * sinAngle + oneMinusCosAngle * axis.y * axis.z;
 502     mOut._24 = 0.0f;
 503
 504     mOut._31 = axis.y * sinAngle + oneMinusCosAngle * axis.z * axis.x;
 505     mOut._32 = -axis.x * sinAngle + oneMinusCosAngle * axis.z * axis.y;
 506     mOut._33 = 1.0f + oneMinusCosAngle * (axis.z * axis.z - 1.0f);
 507     mOut._34 = 0.0f;
 508
 509     mOut._41 = 0.0f;
 510     mOut._42 = 0.0f;
 511     mOut._43 = 0.0f;
 512     mOut._44 = 1.0f;
 513
 514     return mOut;
 515 }