headers: Add directxmath.h with some basic declarations.
Signed-off-by: Biswapriyo Nath <nathbappai@gmail.com>
Signed-off-by: Liu Hao <lh_mouse@126.com>
diff --git a/mingw-w64-headers/include/directxmath.h b/mingw-w64-headers/include/directxmath.h
new file mode 100644
index 0000000..7e4a220
--- /dev/null
+++ b/mingw-w64-headers/include/directxmath.h
@@ -0,0 +1,326 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#ifndef DIRECTXMATH_H
+#define DIRECTXMATH_H
+
+#ifndef __cplusplus
+#error DirectX Math requires C++
+#endif
+
+#include <stdint.h>
+
+#define DIRECTX_MATH_VERSION 314
+
+#define XM_CONST const
+#if __cplusplus >= 201103L
+#define XM_CONSTEXPR constexpr
+#else
+#define XM_CONSTEXPR
+#endif
+
+namespace DirectX {
+
+struct XMFLOAT2 {
+ float x, y;
+ XMFLOAT2() = default;
+ XMFLOAT2(const XMFLOAT2&) = default;
+ XMFLOAT2& operator=(const XMFLOAT2&) = default;
+ XMFLOAT2(XMFLOAT2&&) = default;
+ XMFLOAT2& operator=(XMFLOAT2&&) = default;
+ XM_CONSTEXPR XMFLOAT2(float _x, float _y) : x(_x), y(_y) {}
+ explicit XMFLOAT2(const float *pArray) : x(pArray[0]), y(pArray[1]) {}
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT2A : public XMFLOAT2 {
+ XMFLOAT2A() = default;
+ XMFLOAT2A(const XMFLOAT2A&) = default;
+ XMFLOAT2A& operator=(const XMFLOAT2A&) = default;
+ XMFLOAT2A(XMFLOAT2A&&) = default;
+ XMFLOAT2A& operator=(XMFLOAT2A&&) = default;
+ XM_CONSTEXPR XMFLOAT2A(float _x, float _y) : XMFLOAT2(_x, _y) {}
+ explicit XMFLOAT2A(const float *pArray) : XMFLOAT2(pArray) {}
+};
+
+struct XMINT2 {
+ int32_t x, y;
+ XMINT2() = default;
+ XMINT2(const XMINT2&) = default;
+ XMINT2& operator=(const XMINT2&) = default;
+ XMINT2(XMINT2&&) = default;
+ XMINT2& operator=(XMINT2&&) = default;
+ XM_CONSTEXPR XMINT2(int32_t _x, int32_t _y) : x(_x), y(_y) {}
+ explicit XMINT2(const int32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
+};
+
+struct XMUINT2 {
+ uint32_t x, y;
+ XMUINT2() = default;
+ XMUINT2(const XMUINT2&) = default;
+ XMUINT2& operator=(const XMUINT2&) = default;
+ XMUINT2(XMUINT2&&) = default;
+ XMUINT2& operator=(XMUINT2&&) = default;
+ XM_CONSTEXPR XMUINT2(uint32_t _x, uint32_t _y) : x(_x), y(_y) {}
+ explicit XMUINT2(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
+};
+
+struct XMFLOAT3 {
+ float x, y, z;
+ XMFLOAT3() = default;
+ XMFLOAT3(const XMFLOAT3&) = default;
+ XMFLOAT3& operator=(const XMFLOAT3&) = default;
+ XMFLOAT3(XMFLOAT3&&) = default;
+ XMFLOAT3& operator=(XMFLOAT3&&) = default;
+ XM_CONSTEXPR XMFLOAT3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
+ explicit XMFLOAT3(const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT3A : public XMFLOAT3 {
+ XMFLOAT3A() = default;
+ XMFLOAT3A(const XMFLOAT3A&) = default;
+ XMFLOAT3A& operator=(const XMFLOAT3A&) = default;
+ XMFLOAT3A(XMFLOAT3A&&) = default;
+ XMFLOAT3A& operator=(XMFLOAT3A&&) = default;
+ XM_CONSTEXPR XMFLOAT3A(float _x, float _y, float _z) : XMFLOAT3(_x, _y, _z) {}
+ explicit XMFLOAT3A(const float *pArray) : XMFLOAT3(pArray) {}
+};
+
+struct XMINT3 {
+ int32_t x, y, z;
+ XMINT3() = default;
+ XMINT3(const XMINT3&) = default;
+ XMINT3& operator=(const XMINT3&) = default;
+ XMINT3(XMINT3&&) = default;
+ XMINT3& operator=(XMINT3&&) = default;
+ XM_CONSTEXPR XMINT3(int32_t _x, int32_t _y, int32_t _z) : x(_x), y(_y), z(_z) {}
+ explicit XMINT3(const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
+};
+
+struct XMUINT3 {
+ uint32_t x, y, z;
+ XMUINT3() = default;
+ XMUINT3(const XMUINT3&) = default;
+ XMUINT3& operator=(const XMUINT3&) = default;
+ XMUINT3(XMUINT3&&) = default;
+ XMUINT3& operator=(XMUINT3&&) = default;
+ XM_CONSTEXPR XMUINT3(uint32_t _x, uint32_t _y, uint32_t _z) : x(_x), y(_y), z(_z) {}
+ explicit XMUINT3(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
+};
+
+struct XMFLOAT4 {
+ float x, y, z, w;
+ XMFLOAT4() = default;
+ XMFLOAT4(const XMFLOAT4&) = default;
+ XMFLOAT4& operator=(const XMFLOAT4&) = default;
+ XMFLOAT4(XMFLOAT4&&) = default;
+ XMFLOAT4& operator=(XMFLOAT4&&) = default;
+ XM_CONSTEXPR XMFLOAT4(float _x, float _y, float _z, float _w) : x(_x), y(_y), z(_z), w(_w) {}
+ explicit XMFLOAT4(const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT4A : public XMFLOAT4 {
+ XMFLOAT4A() = default;
+ XMFLOAT4A(const XMFLOAT4A&) = default;
+ XMFLOAT4A& operator=(const XMFLOAT4A&) = default;
+ XMFLOAT4A(XMFLOAT4A&&) = default;
+ XMFLOAT4A& operator=(XMFLOAT4A&&) = default;
+ XM_CONSTEXPR XMFLOAT4A(float _x, float _y, float _z, float _w) : XMFLOAT4(_x, _y, _z, _w) {}
+ explicit XMFLOAT4A(const float *pArray) : XMFLOAT4(pArray) {}
+};
+
+struct XMINT4 {
+ int32_t x, y, z, w;
+ XMINT4() = default;
+ XMINT4(const XMINT4&) = default;
+ XMINT4& operator=(const XMINT4&) = default;
+ XMINT4(XMINT4&&) = default;
+ XMINT4& operator=(XMINT4&&) = default;
+ XM_CONSTEXPR XMINT4(int32_t _x, int32_t _y, int32_t _z, int32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
+ explicit XMINT4(const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
+};
+
+struct XMUINT4 {
+ uint32_t x, y, z, w;
+ XMUINT4() = default;
+ XMUINT4(const XMUINT4&) = default;
+ XMUINT4& operator=(const XMUINT4&) = default;
+ XMUINT4(XMUINT4&&) = default;
+ XMUINT4& operator=(XMUINT4&&) = default;
+ XM_CONSTEXPR XMUINT4(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
+ explicit XMUINT4(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
+};
+
+struct XMFLOAT3X3 {
+ union
+ {
+ struct
+ {
+ float _11, _12, _13;
+ float _21, _22, _23;
+ float _31, _32, _33;
+ };
+ float m[3][3];
+ };
+
+ XMFLOAT3X3() = default;
+ XMFLOAT3X3(const XMFLOAT3X3&) = default;
+ XMFLOAT3X3& operator=(const XMFLOAT3X3&) = default;
+ XMFLOAT3X3(XMFLOAT3X3&&) = default;
+ XMFLOAT3X3& operator=(XMFLOAT3X3&&) = default;
+ XM_CONSTEXPR XMFLOAT3X3(
+ float m00, float m01, float m02,
+ float m10, float m11, float m12,
+ float m20, float m21, float m22)
+ : _11(m00), _12(m01), _13(m02),
+ _21(m10), _22(m11), _23(m12),
+ _31(m20), _32(m21), _33(m22) {}
+ explicit XMFLOAT3X3(const float *pArray);
+ float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
+ float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
+ };
+
+struct XMFLOAT4X3 {
+ union
+ {
+ struct
+ {
+ float _11, _12, _13;
+ float _21, _22, _23;
+ float _31, _32, _33;
+ float _41, _42, _43;
+ };
+ float m[4][3];
+ float f[12];
+ };
+
+ XMFLOAT4X3() = default;
+ XMFLOAT4X3(const XMFLOAT4X3&) = default;
+ XMFLOAT4X3& operator=(const XMFLOAT4X3&) = default;
+ XMFLOAT4X3(XMFLOAT4X3&&) = default;
+ XMFLOAT4X3& operator=(XMFLOAT4X3&&) = default;
+ XM_CONSTEXPR XMFLOAT4X3(
+ float m00, float m01, float m02,
+ float m10, float m11, float m12,
+ float m20, float m21, float m22,
+ float m30, float m31, float m32)
+ : _11(m00), _12(m01), _13(m02),
+ _21(m10), _22(m11), _23(m12),
+ _31(m20), _32(m21), _33(m22),
+ _41(m30), _42(m31), _43(m32) {}
+ explicit XMFLOAT4X3(const float *pArray);
+ float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
+ float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT4X3A : public XMFLOAT4X3 {
+ XMFLOAT4X3A() = default;
+ XMFLOAT4X3A(const XMFLOAT4X3A&) = default;
+ XMFLOAT4X3A& operator=(const XMFLOAT4X3A&) = default;
+ XMFLOAT4X3A(XMFLOAT4X3A&&) = default;
+ XMFLOAT4X3A& operator=(XMFLOAT4X3A&&) = default;
+ XM_CONSTEXPR XMFLOAT4X3A(
+ float m00, float m01, float m02,
+ float m10, float m11, float m12,
+ float m20, float m21, float m22,
+ float m30, float m31, float m32) :
+ XMFLOAT4X3(m00,m01,m02,m10,m11,m12,m20,m21,m22,m30,m31,m32) {}
+ explicit XMFLOAT4X3A(const float *pArray) : XMFLOAT4X3(pArray) {}
+};
+
+struct XMFLOAT3X4 {
+ union
+ {
+ struct
+ {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ };
+ float m[3][4];
+ float f[12];
+ };
+
+ XMFLOAT3X4() = default;
+ XMFLOAT3X4(const XMFLOAT3X4&) = default;
+ XMFLOAT3X4& operator=(const XMFLOAT3X4&) = default;
+ XMFLOAT3X4(XMFLOAT3X4&&) = default;
+ XMFLOAT3X4& operator=(XMFLOAT3X4&&) = default;
+ XM_CONSTEXPR XMFLOAT3X4(
+ float m00, float m01, float m02, float m03,
+ float m10, float m11, float m12, float m13,
+ float m20, float m21, float m22, float m23)
+ : _11(m00), _12(m01), _13(m02), _14(m03),
+ _21(m10), _22(m11), _23(m12), _24(m13),
+ _31(m20), _32(m21), _33(m22), _34(m23) {}
+ explicit XMFLOAT3X4(const float *pArray);
+ float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
+ float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT3X4A : public XMFLOAT3X4 {
+ XMFLOAT3X4A() = default;
+ XMFLOAT3X4A(const XMFLOAT3X4A&) = default;
+ XMFLOAT3X4A& operator=(const XMFLOAT3X4A&) = default;
+ XMFLOAT3X4A(XMFLOAT3X4A&&) = default;
+ XMFLOAT3X4A& operator=(XMFLOAT3X4A&&) = default;
+ XM_CONSTEXPR XMFLOAT3X4A(
+ float m00, float m01, float m02, float m03,
+ float m10, float m11, float m12, float m13,
+ float m20, float m21, float m22, float m23) :
+ XMFLOAT3X4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23) {}
+ explicit XMFLOAT3X4A(const float *pArray) : XMFLOAT3X4(pArray) {}
+};
+
+struct XMFLOAT4X4 {
+ union
+ {
+ struct
+ {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ float _41, _42, _43, _44;
+ };
+ float m[4][4];
+ };
+
+ XMFLOAT4X4() = default;
+ XMFLOAT4X4(const XMFLOAT4X4&) = default;
+ XMFLOAT4X4& operator=(const XMFLOAT4X4&) = default;
+ XMFLOAT4X4(XMFLOAT4X4&&) = default;
+ XMFLOAT4X4& operator=(XMFLOAT4X4&&) = default;
+ XM_CONSTEXPR XMFLOAT4X4(
+ float m00, float m01, float m02, float m03,
+ float m10, float m11, float m12, float m13,
+ float m20, float m21, float m22, float m23,
+ float m30, float m31, float m32, float m33)
+ : _11(m00), _12(m01), _13(m02), _14(m03),
+ _21(m10), _22(m11), _23(m12), _24(m13),
+ _31(m20), _32(m21), _33(m22), _34(m23),
+ _41(m30), _42(m31), _43(m32), _44(m33) {}
+ explicit XMFLOAT4X4(const float *pArray);
+ float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
+ float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
+};
+
+struct __attribute__ ((__aligned__ (16))) XMFLOAT4X4A : public XMFLOAT4X4 {
+ XMFLOAT4X4A() = default;
+ XMFLOAT4X4A(const XMFLOAT4X4A&) = default;
+ XMFLOAT4X4A& operator=(const XMFLOAT4X4A&) = default;
+ XMFLOAT4X4A(XMFLOAT4X4A&&) = default;
+ XMFLOAT4X4A& operator=(XMFLOAT4X4A&&) = default;
+ XM_CONSTEXPR XMFLOAT4X4A(
+ float m00, float m01, float m02, float m03,
+ float m10, float m11, float m12, float m13,
+ float m20, float m21, float m22, float m23,
+ float m30, float m31, float m32, float m33)
+ : XMFLOAT4X4(m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33) {}
+ explicit XMFLOAT4X4A(const float *pArray) : XMFLOAT4X4(pArray) {}
+};
+
+} /* namespace DirectX */
+
+#endif /* DIRECTXMATH_H */
