Add typedefs for half-float and 8-/16-bit packed matrices.

doc/changelog.dox

@@ -49,6 +49,14 @@ See also:
     @ref Vector2s, @ref Vector3s, @ref Vector4s, @ref Color3h, @ref Color4h,
     @ref Color3us, @ref Color4us convenience typedefs for half-float, 8- and
     16-bit integer vector and color types
+-   New storage-only @ref Matrix2x2h, @ref Matrix2x2b, @ref Matrix2x2s,
+    @ref Matrix2x3h, @ref Matrix2x3b, @ref Matrix2x3s, @ref Matrix2x4h,
+    @ref Matrix2x4b, @ref Matrix2x4s, @ref Matrix3x2h, @ref Matrix3x2b,
+    @ref Matrix3x2s, @ref Matrix3x3h. @ref Matrix3x3b, @ref Matrix3x3s,
+    @ref Matrix3x4h, @ref Matrix3x4b, @ref Matrix3x4s, @ref Matrix4x2h,
+    @ref Matrix4x2b, @ref Matrix4x2s, @ref Matrix4x3h, @ref Matrix4x3b,
+    @ref Matrix4x3s, @ref Matrix4x4h, @ref Matrix4x4b, @ref Matrix4x4s
+    convenience typedefs for half-float, 8- and 16-bit packed matrix types
 -   New @ref VertexFormat enum for vertex formats and related utilities
 -   New @ref MeshPrimitive::Instances, @ref MeshPrimitive::Faces and
     @ref MeshPrimitive::Edges primitive types for describing per-instance,

doc/types.dox

@@ -83,14 +83,23 @@ after type name means @ref Float underlying type, `h` means @ref Half, `d` is
 | Magnum matrix type                                               | Equivalent GLSL type                  |
 | ---------------------------------------------------------------- | ------------------------------------- |
 | @ref Matrix2x2 or @ref Matrix2x2d                                | @glsl mat2 @ce / @glsl mat2x2 @ce or @glsl dmat2 @ce / @glsl dmat2x2 @ce |
+| @ref Matrix2x2h, @ref Matrix2x2b, @ref Matrix2x2s                | (*none*) |
 | @ref Matrix3 / @ref Matrix3x3 or @ref Matrix3d / @ref Matrix3x3d | @glsl mat3 @ce / @glsl mat3x3 @ce or @glsl dmat3 @ce / @glsl dmat3x3 @ce |
+| @ref Matrix3x3h, @ref Matrix3x3b, @ref Matrix3x3s                | (*none*) |
 | @ref Matrix4 / @ref Matrix4x4 or @ref Matrix4d / @ref Matrix4x4d | @glsl mat4 @ce / @glsl mat4x4 @ce or  @glsl dmat4 @ce / @glsl dmat4x4 @ce |
+| @ref Matrix4x4h, @ref Matrix4x4b, @ref Matrix4x4s                | (*none*) |
 | @ref Matrix2x3 or @ref Matrix2x3d                                | @glsl mat2x3 @ce or @glsl dmat2x3 @ce |
+| @ref Matrix2x3h, @ref Matrix2x3b, @ref Matrix2x3s                | (*none*) |
 | @ref Matrix3x2 or @ref Matrix3x2d                                | @glsl mat3x2 @ce or @glsl dmat3x2 @ce |
+| @ref Matrix3x2h, @ref Matrix3x2b, @ref Matrix3x2s                | (*none*) |
 | @ref Matrix2x4 or @ref Matrix2x4d                                | @glsl mat2x4 @ce or @glsl dmat2x4 @ce |
+| @ref Matrix2x4h, @ref Matrix2x4b, @ref Matrix2x4s                | (*none*) |
 | @ref Matrix4x2 or @ref Matrix4x2d                                | @glsl mat4x2 @ce or @glsl dmat4x2 @ce |
+| @ref Matrix4x2h, @ref Matrix4x2b, @ref Matrix4x2s                | (*none*) |
 | @ref Matrix3x4 or @ref Matrix3x4d                                | @glsl mat3x4 @ce or @glsl dmat3x4 @ce |
+| @ref Matrix3x4h, @ref Matrix3x4b, @ref Matrix3x4s                | (*none*) |
 | @ref Matrix4x3 or @ref Matrix4x3d                                | @glsl mat4x3 @ce or @glsl dmat4x3 @ce |
+| @ref Matrix4x3h, @ref Matrix4x3b, @ref Matrix4x3s                | (*none*) |
 
 Any super- or sub-class of the same size and underlying type can be used
 equivalently (e.g. @ref Math::Vector "Math::Vector<Float>" or @ref Color3

src/Magnum/Magnum.h

@@ -522,6 +522,222 @@ Equivalent to GLSL @glsl mat4x3 @ce.
 */
 typedef Math::Matrix4x3<Float> Matrix4x3;
 
+/**
+@brief Signed byte matrix with 2 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix2x4b and ignore the bottom two rows.
+*/
+typedef Math::Matrix2x2<Byte> Matrix2x2b;
+
+/**
+@brief Signed byte matrix with 2 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix2x4b and ignore the bottom row.
+*/
+typedef Math::Matrix2x3<Byte> Matrix2x3b;
+
+/**
+@brief Signed byte matrix with 2 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix2x4<Byte> Matrix2x4b;
+
+/**
+@brief Signed byte matrix with 3 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix3x4b and ignore the bottom two rows.
+*/
+typedef Math::Matrix3x2<Byte> Matrix3x2b;
+
+/**
+@brief Signed byte matrix with 3 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix3x4b and ignore the bottom row.
+*/
+typedef Math::Matrix3x3<Byte> Matrix3x3b;
+
+/**
+@brief Signed byte matrix with 3 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix3x4<Byte> Matrix3x4b;
+
+/**
+@brief Signed byte matrix with 4 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix4x4b and ignore the bottom two rows.
+*/
+typedef Math::Matrix4x2<Byte> Matrix4x2b;
+
+/**
+@brief Signed byte matrix with 4 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix4x4b and ignore the bottom row.
+*/
+typedef Math::Matrix4x3<Byte> Matrix4x3b;
+
+/**
+@brief Signed byte matrix with 4 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 8-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix4x4<Byte> Matrix4x4b;
+
+/**
+@brief Signed short matrix with 2 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix2x2<Short> Matrix2x2s;
+
+/**
+@brief Signed short matrix with 2 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix2x4s and ignore the bottom row.
+*/
+typedef Math::Matrix2x3<Short> Matrix2x3s;
+
+/**
+@brief Signed short matrix with 2 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix2x4<Short> Matrix2x4s;
+
+/**
+@brief Signed short matrix with 3 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix3x2<Short> Matrix3x2s;
+
+/**
+@brief Signed short matrix with 3 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix3x4s and ignore the bottom row.
+*/
+typedef Math::Matrix3x3<Short> Matrix3x3s;
+
+/**
+@brief Signed short matrix with 3 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix3x4<Short> Matrix3x4s;
+
+/**
+@brief Signed short matrix with 4 columns and 2 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix4x2<Short> Matrix4x2s;
+
+/**
+@brief Signed short matrix with 4 columns and 3 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix4x4s and ignore the bottom row.
+*/
+typedef Math::Matrix4x3<Short> Matrix4x3s;
+
+/**
+@brief Signed short matrix with 4 columns and 4 rows
+@m_since_latest
+
+Storage only, in ordet to support matrices packed into 16-bit types. For
+performing arithmetic on this type use @ref Math::unpack() / @ref Math::unpackInto() to convert to a float type first and then @ref Math::pack()
+/ @ref Math::packInto() back again.
+*/
+typedef Math::Matrix4x4<Short> Matrix4x4s;
+
 /** @brief Float two-dimensional quadratic Bézier curve */
 typedef Math::QuadraticBezier2D<Float> QuadraticBezier2D;
 
@@ -596,7 +812,9 @@ typedef Math::Frustum<Float> Frustum;
 /** @{ @name Half-precision types
 
 These types are for storage and conversion from / to single-precision types,
-no arithmetic operations are implemented. See @ref types for more information.
+no arithmetic operations are implemented. See @ref types for more information,
+for performing arithmetic on these types use @ref Math::unpackHalf() / @ref Math::unpackHalfInto() to convert to a 32-bit float type first and then
+@ref Math::packHalf() / @ref Math::packHalfInto() back again.
 */
 
 /**
@@ -629,6 +847,72 @@ typedef Math::Color3<Half> Color3h;
 */
 typedef Math::Color4<Half> Color4h;
 
+/**
+@brief Half-float matrix with 2 columns and 2 rows
+@m_since_latest
+*/
+typedef Math::Matrix2x2<Half> Matrix2x2h;
+
+/**
+@brief Half-float matrix with 2 columns and 3 rows
+@m_since_latest
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix2x4h and ignore the bottom row.
+*/
+typedef Math::Matrix2x3<Half> Matrix2x3h;
+
+/**
+@brief Half-float matrix with 2 columns and 4 rows
+@m_since_latest
+*/
+typedef Math::Matrix2x4<Half> Matrix2x4h;
+
+/**
+@brief Half-float matrix with 3 columns and 2 rows
+@m_since_latest
+*/
+typedef Math::Matrix3x2<Half> Matrix3x2h;
+
+/**
+@brief Half-float matrix with 3 columns and 3 rows
+@m_since_latest
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix3x4h and ignore the bottom row.
+*/
+typedef Math::Matrix3x3<Half> Matrix3x3h;
+
+/**
+@brief Half-float matrix with 3 columns and 4 rows
+@m_since_latest
+*/
+typedef Math::Matrix3x4<Half> Matrix3x4h;
+
+/**
+@brief Half-float matrix with 4 columns and 2 rows
+@m_since_latest
+*/
+typedef Math::Matrix4x2<Half> Matrix4x2h;
+
+/**
+@brief Half-float matrix with 4 columns and 3 rows
+@m_since_latest
+
+Note that this type doesn't have the columns four-byte aligned, which may
+negatively affect performance in some cases. For better alignment use
+@ref Matrix4x4h and ignore the bottom row.
+*/
+typedef Math::Matrix4x3<Half> Matrix4x3h;
+
+/**
+@brief Half-float matrix with 4 columns and 4 rows
+@m_since_latest
+*/
+typedef Math::Matrix4x4<Half> Matrix4x4h;
+
 /*@}*/
 
 /** @{ @name Double-precision types

src/Magnum/Math/Matrix.h

@@ -54,7 +54,12 @@ namespace Implementation {
 See @ref matrix-vector for brief introduction.
 
 @configurationvalueref{Magnum::Math::Matrix}
-@see @ref Matrix2x2, @ref Matrix3x3, @ref Matrix4x4
+@see @ref Matrix2x2, @ref Matrix3x3, @ref Matrix4x4, @ref Magnum::Matrix2x2,
+    @ref Magnum::Matrix2x2d, @ref Magnum::Matrix2x2h, @ref Magnum::Matrix2x2b,
+    @ref Magnum::Matrix2x2s, @ref Magnum::Matrix3x3, @ref Magnum::Matrix3x3d,
+    @ref Magnum::Matrix3x3h, @ref Magnum::Matrix3x3b, @ref Magnum::Matrix3x3s,
+    @ref Magnum::Matrix4x4, @ref Magnum::Matrix4x4d, @ref Magnum::Matrix4x4h,
+    @ref Magnum::Matrix4x4b, @ref Magnum::Matrix4x4s
  */
 template<std::size_t size, class T> class Matrix: public RectangularMatrix<size, size, T> {
     public:
@@ -301,7 +306,8 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
 
 Convenience alternative to `Matrix<2, T>`. See @ref Matrix for more
 information.
-@see @ref Magnum::Matrix2x2, @ref Magnum::Matrix2x2d
+@see @ref Magnum::Matrix2x2, @ref Magnum::Matrix2x2d, @ref Magnum::Matrix2x2h,
+    @ref Magnum::Matrix2x2b, @ref Magnum::Matrix2x2s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix2x2 = Matrix<2, T>;
@@ -313,7 +319,8 @@ template<class T> using Matrix2x2 = Matrix<2, T>;
 Convenience alternative to `Matrix<3, T>`. See @ref Matrix for more
 information. Note that this is different from @ref Matrix3, which contains
 additional functions for transformations in 2D.
-@see @ref Magnum::Matrix3x3, @ref Magnum::Matrix3x3d
+@see @ref Magnum::Matrix3x3, @ref Magnum::Matrix3x3d, @ref Magnum::Matrix3x3h,
+    @ref Magnum::Matrix3x3b, @ref Magnum::Matrix3x3s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix3x3 = Matrix<3, T>;
@@ -325,7 +332,8 @@ template<class T> using Matrix3x3 = Matrix<3, T>;
 Convenience alternative to `Matrix<4, T>`. See @ref Matrix for more
 information. Note that this is different from @ref Matrix4, which contains
 additional functions for transformations in 3D.
-@see @ref Magnum::Matrix4x4, @ref Magnum::Matrix4x4d
+@see @ref Magnum::Matrix4x4, @ref Magnum::Matrix4x4d, @ref Magnum::Matrix4x4h,
+    @ref Magnum::Matrix4x4b, @ref Magnum::Matrix4x4s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix4x4 = Matrix<4, T>;

src/Magnum/Math/RectangularMatrix.h

@@ -50,7 +50,17 @@ The data are stored in column-major order, to reflect that, all indices in
 math formulas are in reverse order (i.e. @f$ \boldsymbol A_{ji} @f$ instead
 of @f$ \boldsymbol A_{ij} @f$).
 @see @ref Matrix2x3, @ref Matrix3x2, @ref Matrix2x4, @ref Matrix4x2,
-    @ref Matrix3x4, @ref Matrix4x3
+    @ref Matrix3x4, @ref Matrix4x3, @ref Magnum::Matrix2x3,
+    @ref Magnum::Matrix2x3d, @ref Magnum::Matrix2x3h, @ref Magnum::Matrix2x3b,
+    @ref Magnum::Matrix2x3s, @ref Magnum::Matrix3x2, @ref Magnum::Matrix3x2d,
+    @ref Magnum::Matrix3x2h, @ref Magnum::Matrix3x2b, @ref Magnum::Matrix3x2s,
+    @ref Magnum::Matrix2x4, @ref Magnum::Matrix2x4d, @ref Magnum::Matrix2x4h,
+    @ref Magnum::Matrix2x4b, @ref Magnum::Matrix2x4s, @ref Magnum::Matrix4x2,
+    @ref Magnum::Matrix4x2d, @ref Magnum::Matrix4x2h, @ref Magnum::Matrix4x2b,
+    @ref Magnum::Matrix4x2s, @ref Magnum::Matrix3x4, @ref Magnum::Matrix3x4d,
+    @ref Magnum::Matrix3x4h, @ref Magnum::Matrix3x4b, @ref Magnum::Matrix3x4s,
+    @ref Magnum::Matrix4x3, @ref Magnum::Matrix4x3d, @ref Magnum::Matrix4x3h,
+    @ref Magnum::Matrix4x3b, @ref Magnum::Matrix4x3s
 */
 template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
     static_assert(cols != 0 && rows != 0, "RectangularMatrix cannot have zero elements");
@@ -470,7 +480,8 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
 
 Convenience alternative to @cpp RectangularMatrix<2, 3, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix2x3, @ref Magnum::Matrix2x3d
+@see @ref Magnum::Matrix2x3, @ref Magnum::Matrix2x3d, @ref Magnum::Matrix2x3h,
+    @ref Magnum::Matrix2x3b, @ref Magnum::Matrix2x3s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix2x3 = RectangularMatrix<2, 3, T>;
@@ -481,7 +492,8 @@ template<class T> using Matrix2x3 = RectangularMatrix<2, 3, T>;
 
 Convenience alternative to @cpp RectangularMatrix<3, 2, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix3x2, @ref Magnum::Matrix3x2d
+@see @ref Magnum::Matrix3x2, @ref Magnum::Matrix3x2d, @ref Magnum::Matrix3x2h,
+    @ref Magnum::Matrix3x2b, @ref Magnum::Matrix3x2s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix3x2 = RectangularMatrix<3, 2, T>;
@@ -492,7 +504,8 @@ template<class T> using Matrix3x2 = RectangularMatrix<3, 2, T>;
 
 Convenience alternative to @cpp RectangularMatrix<2, 4, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix2x4, @ref Magnum::Matrix2x4d
+@see @ref Magnum::Matrix2x4, @ref Magnum::Matrix2x4d, @ref Magnum::Matrix2x4h,
+    @ref Magnum::Matrix2x4b, @ref Magnum::Matrix2x4s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix2x4 = RectangularMatrix<2, 4, T>;
@@ -503,7 +516,8 @@ template<class T> using Matrix2x4 = RectangularMatrix<2, 4, T>;
 
 Convenience alternative to @cpp RectangularMatrix<4, 2, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix4x2, @ref Magnum::Matrix4x2d
+@see @ref Magnum::Matrix4x2, @ref Magnum::Matrix4x2d, @ref Magnum::Matrix4x2h,
+    @ref Magnum::Matrix4x2b, @ref Magnum::Matrix4x2s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix4x2 = RectangularMatrix<4, 2, T>;
@@ -514,7 +528,8 @@ template<class T> using Matrix4x2 = RectangularMatrix<4, 2, T>;
 
 Convenience alternative to @cpp RectangularMatrix<3, 4, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix3x4, @ref Magnum::Matrix3x4d
+@see @ref Magnum::Matrix3x4, @ref Magnum::Matrix3x4d, @ref Magnum::Matrix3x4h,
+    @ref Magnum::Matrix3x4b, @ref Magnum::Matrix3x4s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix3x4 = RectangularMatrix<3, 4, T>;
@@ -525,7 +540,8 @@ template<class T> using Matrix3x4 = RectangularMatrix<3, 4, T>;
 
 Convenience alternative to @cpp RectangularMatrix<4, 3, T> @ce. See
 @ref RectangularMatrix for more information.
-@see @ref Magnum::Matrix4x3, @ref Magnum::Matrix4x3d
+@see @ref Magnum::Matrix4x3, @ref Magnum::Matrix4x3d, @ref Magnum::Matrix4x3h,
+    @ref Magnum::Matrix4x3b, @ref Magnum::Matrix4x3s
 */
 #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Multiple definitions still broken */
 template<class T> using Matrix4x3 = RectangularMatrix<4, 3, T>;