i686-w64-mingw32/include/directxmath.h

/**
 * 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 */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	10988 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	/**
2	* This file has no copyright assigned and is placed in the Public Domain.
3	* This file is part of the mingw-w64 runtime package.
4	* No warranty is given; refer to the file DISCLAIMER.PD within this package.
5	*/
6
7	#ifndef DIRECTXMATH_H
8	#define DIRECTXMATH_H
9
10	#ifndef __cplusplus
11	#error DirectX Math requires C++
12	#endif
13
14	#include <stdint.h>
15
16	#define DIRECTX_MATH_VERSION 314
17
18	#define XM_CONST const
19	#if __cplusplus >= 201103L
20	#define XM_CONSTEXPR constexpr
21	#else
22	#define XM_CONSTEXPR
23	#endif
24
25	namespace DirectX {
26
27	struct XMFLOAT2 {
28	float x, y;
29	XMFLOAT2() = default;
30	XMFLOAT2(const XMFLOAT2&) = default;
31	XMFLOAT2& operator=(const XMFLOAT2&) = default;
32	XMFLOAT2(XMFLOAT2&&) = default;
33	XMFLOAT2& operator=(XMFLOAT2&&) = default;
34	XM_CONSTEXPR XMFLOAT2(float _x, float _y) : x(_x), y(_y) {}
35	explicit XMFLOAT2(const float *pArray) : x(pArray[0]), y(pArray[1]) {}
36	};
37
38	struct __attribute__ ((__aligned__ (16))) XMFLOAT2A : public XMFLOAT2 {
39	XMFLOAT2A() = default;
40	XMFLOAT2A(const XMFLOAT2A&) = default;
41	XMFLOAT2A& operator=(const XMFLOAT2A&) = default;
42	XMFLOAT2A(XMFLOAT2A&&) = default;
43	XMFLOAT2A& operator=(XMFLOAT2A&&) = default;
44	XM_CONSTEXPR XMFLOAT2A(float _x, float _y) : XMFLOAT2(_x, _y) {}
45	explicit XMFLOAT2A(const float *pArray) : XMFLOAT2(pArray) {}
46	};
47
48	struct XMINT2 {
49	int32_t x, y;
50	XMINT2() = default;
51	XMINT2(const XMINT2&) = default;
52	XMINT2& operator=(const XMINT2&) = default;
53	XMINT2(XMINT2&&) = default;
54	XMINT2& operator=(XMINT2&&) = default;
55	XM_CONSTEXPR XMINT2(int32_t _x, int32_t _y) : x(_x), y(_y) {}
56	explicit XMINT2(const int32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
57	};
58
59	struct XMUINT2 {
60	uint32_t x, y;
61	XMUINT2() = default;
62	XMUINT2(const XMUINT2&) = default;
63	XMUINT2& operator=(const XMUINT2&) = default;
64	XMUINT2(XMUINT2&&) = default;
65	XMUINT2& operator=(XMUINT2&&) = default;
66	XM_CONSTEXPR XMUINT2(uint32_t _x, uint32_t _y) : x(_x), y(_y) {}
67	explicit XMUINT2(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
68	};
69
70	struct XMFLOAT3 {
71	float x, y, z;
72	XMFLOAT3() = default;
73	XMFLOAT3(const XMFLOAT3&) = default;
74	XMFLOAT3& operator=(const XMFLOAT3&) = default;
75	XMFLOAT3(XMFLOAT3&&) = default;
76	XMFLOAT3& operator=(XMFLOAT3&&) = default;
77	XM_CONSTEXPR XMFLOAT3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
78	explicit XMFLOAT3(const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
79	};
80
81	struct __attribute__ ((__aligned__ (16))) XMFLOAT3A : public XMFLOAT3 {
82	XMFLOAT3A() = default;
83	XMFLOAT3A(const XMFLOAT3A&) = default;
84	XMFLOAT3A& operator=(const XMFLOAT3A&) = default;
85	XMFLOAT3A(XMFLOAT3A&&) = default;
86	XMFLOAT3A& operator=(XMFLOAT3A&&) = default;
87	XM_CONSTEXPR XMFLOAT3A(float _x, float _y, float _z) : XMFLOAT3(_x, _y, _z) {}
88	explicit XMFLOAT3A(const float *pArray) : XMFLOAT3(pArray) {}
89	};
90
91	struct XMINT3 {
92	int32_t x, y, z;
93	XMINT3() = default;
94	XMINT3(const XMINT3&) = default;
95	XMINT3& operator=(const XMINT3&) = default;
96	XMINT3(XMINT3&&) = default;
97	XMINT3& operator=(XMINT3&&) = default;
98	XM_CONSTEXPR XMINT3(int32_t _x, int32_t _y, int32_t _z) : x(_x), y(_y), z(_z) {}
99	explicit XMINT3(const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
100	};
101
102	struct XMUINT3 {
103	uint32_t x, y, z;
104	XMUINT3() = default;
105	XMUINT3(const XMUINT3&) = default;
106	XMUINT3& operator=(const XMUINT3&) = default;
107	XMUINT3(XMUINT3&&) = default;
108	XMUINT3& operator=(XMUINT3&&) = default;
109	XM_CONSTEXPR XMUINT3(uint32_t _x, uint32_t _y, uint32_t _z) : x(_x), y(_y), z(_z) {}
110	explicit XMUINT3(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
111	};
112
113	struct XMFLOAT4 {
114	float x, y, z, w;
115	XMFLOAT4() = default;
116	XMFLOAT4(const XMFLOAT4&) = default;
117	XMFLOAT4& operator=(const XMFLOAT4&) = default;
118	XMFLOAT4(XMFLOAT4&&) = default;
119	XMFLOAT4& operator=(XMFLOAT4&&) = default;
120	XM_CONSTEXPR XMFLOAT4(float _x, float _y, float _z, float _w) : x(_x), y(_y), z(_z), w(_w) {}
121	explicit XMFLOAT4(const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
122	};
123
124	struct __attribute__ ((__aligned__ (16))) XMFLOAT4A : public XMFLOAT4 {
125	XMFLOAT4A() = default;
126	XMFLOAT4A(const XMFLOAT4A&) = default;
127	XMFLOAT4A& operator=(const XMFLOAT4A&) = default;
128	XMFLOAT4A(XMFLOAT4A&&) = default;
129	XMFLOAT4A& operator=(XMFLOAT4A&&) = default;
130	XM_CONSTEXPR XMFLOAT4A(float _x, float _y, float _z, float _w) : XMFLOAT4(_x, _y, _z, _w) {}
131	explicit XMFLOAT4A(const float *pArray) : XMFLOAT4(pArray) {}
132	};
133
134	struct XMINT4 {
135	int32_t x, y, z, w;
136	XMINT4() = default;
137	XMINT4(const XMINT4&) = default;
138	XMINT4& operator=(const XMINT4&) = default;
139	XMINT4(XMINT4&&) = default;
140	XMINT4& operator=(XMINT4&&) = default;
141	XM_CONSTEXPR XMINT4(int32_t _x, int32_t _y, int32_t _z, int32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
142	explicit XMINT4(const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
143	};
144
145	struct XMUINT4 {
146	uint32_t x, y, z, w;
147	XMUINT4() = default;
148	XMUINT4(const XMUINT4&) = default;
149	XMUINT4& operator=(const XMUINT4&) = default;
150	XMUINT4(XMUINT4&&) = default;
151	XMUINT4& operator=(XMUINT4&&) = default;
152	XM_CONSTEXPR XMUINT4(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
153	explicit XMUINT4(const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
154	};
155
156	struct XMFLOAT3X3 {
157	union
158	{
159	struct
160	{
161	float _11, _12, _13;
162	float _21, _22, _23;
163	float _31, _32, _33;
164	};
165	float m[3][3];
166	};
167
168	XMFLOAT3X3() = default;
169	XMFLOAT3X3(const XMFLOAT3X3&) = default;
170	XMFLOAT3X3& operator=(const XMFLOAT3X3&) = default;
171	XMFLOAT3X3(XMFLOAT3X3&&) = default;
172	XMFLOAT3X3& operator=(XMFLOAT3X3&&) = default;
173	XM_CONSTEXPR XMFLOAT3X3(
174	float m00, float m01, float m02,
175	float m10, float m11, float m12,
176	float m20, float m21, float m22)
177	: _11(m00), _12(m01), _13(m02),
178	_21(m10), _22(m11), _23(m12),
179	_31(m20), _32(m21), _33(m22) {}
180	explicit XMFLOAT3X3(const float *pArray);
181	float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
182	float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
183	};
184
185	struct XMFLOAT4X3 {
186	union
187	{
188	struct
189	{
190	float _11, _12, _13;
191	float _21, _22, _23;
192	float _31, _32, _33;
193	float _41, _42, _43;
194	};
195	float m[4][3];
196	float f[12];
197	};
198
199	XMFLOAT4X3() = default;
200	XMFLOAT4X3(const XMFLOAT4X3&) = default;
201	XMFLOAT4X3& operator=(const XMFLOAT4X3&) = default;
202	XMFLOAT4X3(XMFLOAT4X3&&) = default;
203	XMFLOAT4X3& operator=(XMFLOAT4X3&&) = default;
204	XM_CONSTEXPR XMFLOAT4X3(
205	float m00, float m01, float m02,
206	float m10, float m11, float m12,
207	float m20, float m21, float m22,
208	float m30, float m31, float m32)
209	: _11(m00), _12(m01), _13(m02),
210	_21(m10), _22(m11), _23(m12),
211	_31(m20), _32(m21), _33(m22),
212	_41(m30), _42(m31), _43(m32) {}
213	explicit XMFLOAT4X3(const float *pArray);
214	float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
215	float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
216	};
217
218	struct __attribute__ ((__aligned__ (16))) XMFLOAT4X3A : public XMFLOAT4X3 {
219	XMFLOAT4X3A() = default;
220	XMFLOAT4X3A(const XMFLOAT4X3A&) = default;
221	XMFLOAT4X3A& operator=(const XMFLOAT4X3A&) = default;
222	XMFLOAT4X3A(XMFLOAT4X3A&&) = default;
223	XMFLOAT4X3A& operator=(XMFLOAT4X3A&&) = default;
224	XM_CONSTEXPR XMFLOAT4X3A(
225	float m00, float m01, float m02,
226	float m10, float m11, float m12,
227	float m20, float m21, float m22,
228	float m30, float m31, float m32) :
229	XMFLOAT4X3(m00,m01,m02,m10,m11,m12,m20,m21,m22,m30,m31,m32) {}
230	explicit XMFLOAT4X3A(const float *pArray) : XMFLOAT4X3(pArray) {}
231	};
232
233	struct XMFLOAT3X4 {
234	union
235	{
236	struct
237	{
238	float _11, _12, _13, _14;
239	float _21, _22, _23, _24;
240	float _31, _32, _33, _34;
241	};
242	float m[3][4];
243	float f[12];
244	};
245
246	XMFLOAT3X4() = default;
247	XMFLOAT3X4(const XMFLOAT3X4&) = default;
248	XMFLOAT3X4& operator=(const XMFLOAT3X4&) = default;
249	XMFLOAT3X4(XMFLOAT3X4&&) = default;
250	XMFLOAT3X4& operator=(XMFLOAT3X4&&) = default;
251	XM_CONSTEXPR XMFLOAT3X4(
252	float m00, float m01, float m02, float m03,
253	float m10, float m11, float m12, float m13,
254	float m20, float m21, float m22, float m23)
255	: _11(m00), _12(m01), _13(m02), _14(m03),
256	_21(m10), _22(m11), _23(m12), _24(m13),
257	_31(m20), _32(m21), _33(m22), _34(m23) {}
258	explicit XMFLOAT3X4(const float *pArray);
259	float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
260	float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
261	};
262
263	struct __attribute__ ((__aligned__ (16))) XMFLOAT3X4A : public XMFLOAT3X4 {
264	XMFLOAT3X4A() = default;
265	XMFLOAT3X4A(const XMFLOAT3X4A&) = default;
266	XMFLOAT3X4A& operator=(const XMFLOAT3X4A&) = default;
267	XMFLOAT3X4A(XMFLOAT3X4A&&) = default;
268	XMFLOAT3X4A& operator=(XMFLOAT3X4A&&) = default;
269	XM_CONSTEXPR XMFLOAT3X4A(
270	float m00, float m01, float m02, float m03,
271	float m10, float m11, float m12, float m13,
272	float m20, float m21, float m22, float m23) :
273	XMFLOAT3X4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23) {}
274	explicit XMFLOAT3X4A(const float *pArray) : XMFLOAT3X4(pArray) {}
275	};
276
277	struct XMFLOAT4X4 {
278	union
279	{
280	struct
281	{
282	float _11, _12, _13, _14;
283	float _21, _22, _23, _24;
284	float _31, _32, _33, _34;
285	float _41, _42, _43, _44;
286	};
287	float m[4][4];
288	};
289
290	XMFLOAT4X4() = default;
291	XMFLOAT4X4(const XMFLOAT4X4&) = default;
292	XMFLOAT4X4& operator=(const XMFLOAT4X4&) = default;
293	XMFLOAT4X4(XMFLOAT4X4&&) = default;
294	XMFLOAT4X4& operator=(XMFLOAT4X4&&) = default;
295	XM_CONSTEXPR XMFLOAT4X4(
296	float m00, float m01, float m02, float m03,
297	float m10, float m11, float m12, float m13,
298	float m20, float m21, float m22, float m23,
299	float m30, float m31, float m32, float m33)
300	: _11(m00), _12(m01), _13(m02), _14(m03),
301	_21(m10), _22(m11), _23(m12), _24(m13),
302	_31(m20), _32(m21), _33(m22), _34(m23),
303	_41(m30), _42(m31), _43(m32), _44(m33) {}
304	explicit XMFLOAT4X4(const float *pArray);
305	float operator() (size_t Row, size_t Column) const { return m[Row][Column]; }
306	float& operator() (size_t Row, size_t Column) { return m[Row][Column]; }
307	};
308
309	struct __attribute__ ((__aligned__ (16))) XMFLOAT4X4A : public XMFLOAT4X4 {
310	XMFLOAT4X4A() = default;
311	XMFLOAT4X4A(const XMFLOAT4X4A&) = default;
312	XMFLOAT4X4A& operator=(const XMFLOAT4X4A&) = default;
313	XMFLOAT4X4A(XMFLOAT4X4A&&) = default;
314	XMFLOAT4X4A& operator=(XMFLOAT4X4A&&) = default;
315	XM_CONSTEXPR XMFLOAT4X4A(
316	float m00, float m01, float m02, float m03,
317	float m10, float m11, float m12, float m13,
318	float m20, float m21, float m22, float m23,
319	float m30, float m31, float m32, float m33)
320	: XMFLOAT4X4(m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33) {}
321	explicit XMFLOAT4X4A(const float *pArray) : XMFLOAT4X4(pArray) {}
322	};
323
324	} /* namespace DirectX */
325
326	#endif /* DIRECTXMATH_H */