Dogcows Code - chaz/yoink/blob - src/matrix.hh

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #ifndef _MATRIX_HH_
  30 #define _MATRIX_HH_
  31
  32 /**
  33  * @file matrix.hh
  34  * Matrix classes.
  35  */
  36
  37 #include <cassert>
  38
  39 #include "math.hh"
  40
  41
  42 namespace dc {
  43
  44 /**
  45  * 3x3 matrix.
  46  */
  47
  48 struct matrix3
  49 {
  50         matrix3() {}
  51         matrix3(scalar M11, scalar M12, scalar M13,
  52                         scalar M21, scalar M22, scalar M23,
  53                         scalar M31, scalar M32, scalar M33)
  54         {
  55                 m11 = M11; m12 = M12; m13 = M13;
  56                 m21 = M21; m22 = M22; m23 = M23;
  57                 m31 = M31; m32 = M32; m33 = M33;
  58         }
  59         matrix3(scalar m[9])
  60         {
  61                 array[0] = m[0]; array[1] = m[1]; array[2] = m[2];
  62                 array[3] = m[3]; array[4] = m[4]; array[5] = m[5];
  63                 array[6] = m[6]; array[7] = m[7]; array[8] = m[8];
  64         }
  65
  66         const scalar& operator[](int i) const
  67         {
  68                 assert(i >= 0 && i <= 8 && "Index into matrix3 out of bounds.");
  69                 return array[i];
  70         }
  71         scalar& operator[](int i)
  72         {
  73                 assert(i >= 0 && i <= 8 && "Index into matrix3 out of bounds.");
  74                 return array[i];
  75         }
  76
  77         matrix3 operator+(const matrix3& m) const
  78         {
  79                 return matrix3(m11 + m.m11, m12 + m.m12, m13 + m.m13,
  80                                            m21 + m.m21, m22 + m.m22, m23 + m.m23,
  81                                            m31 + m.m31, m32 + m.m32, m33 + m.m33);
  82         }
  83         matrix3 operator-(const matrix3& m) const
  84         {
  85                 return matrix3(m11 - m.m11, m12 - m.m12, m13 - m.m13,
  86                                            m21 - m.m21, m22 - m.m22, m23 - m.m23,
  87                                            m31 - m.m31, m32 - m.m32, m33 - m.m33);
  88         }
  89         matrix3 operator*(const matrix3& m) const
  90         {
  91                 return matrix3(m11 * m.m11 + m12 * m.m21 + m13 * m.m31,
  92                                            m11 * m.m12 + m12 * m.m22 + m13 * m.m32,
  93                                            m11 * m.m13 + m12 * m.m23 + m13 * m.m33,
  94                                            m21 * m.m11 + m22 * m.m21 + m23 * m.m31,
  95                                            m21 * m.m12 + m22 * m.m22 + m23 * m.m32,
  96                                            m21 * m.m13 + m22 * m.m23 + m23 * m.m33,
  97                                            m31 * m.m11 + m32 * m.m21 + m33 * m.m31,
  98                                            m31 * m.m12 + m32 * m.m22 + m33 * m.m32,
  99                                            m32 * m.m13 + m32 * m.m23 + m33 * m.m33);
 100         }
 101         matrix3 operator*(scalar s) const
 102         {
 103                 return matrix3(m11 * s, m12 * s, m13 * s,
 104                                            m21 * s, m22 * s, m23 * s,
 105                                            m31 * s, m32 * s, m33 * s);
 106         }
 107         matrix3 operator/(scalar s) const
 108         {
 109                 return matrix3(m11 / s, m12 / s, m13 / s,
 110                                            m21 / s, m22 / s, m23 / s,
 111                                            m31 / s, m32 / s, m33 / s);
 112         }
 113
 114         matrix3& operator+=(const matrix3& m)
 115         {
 116                 m11 += m.m11; m12 += m.m12; m13 += m.m13;
 117                 m21 += m.m21; m22 += m.m22; m23 += m.m23;
 118                 m31 += m.m31; m32 += m.m32; m33 += m.m33;
 119                 return *this;
 120         }
 121         matrix3& operator-=(const matrix3& m)
 122         {
 123                 m11 -= m.m11; m12 -= m.m12; m13 -= m.m13;
 124                 m21 -= m.m21; m22 -= m.m22; m23 -= m.m23;
 125                 m31 -= m.m31; m32 -= m.m32; m33 -= m.m33;
 126                 return *this;
 127         }
 128         matrix3& operator*=(const matrix3& m)
 129         {
 130                 return *this = *this * m;
 131         }
 132         matrix3& operator*=(scalar s)
 133         {
 134                 m11 *= s; m12 *= s; m13 *= s;
 135                 m21 *= s; m22 *= s; m23 *= s;
 136                 m31 *= s; m32 *= s; m33 *= s;
 137                 return *this;
 138         }
 139         matrix3& operator/=(scalar s)
 140         {
 141                 m11 /= s; m12 /= s; m13 /= s;
 142                 m21 /= s; m22 /= s; m23 /= s;
 143                 m31 /= s; m32 /= s; m33 /= s;
 144                 return *this;
 145         }
 146
 147         matrix3 operator-() const
 148         {
 149                 return matrix3(-m11, -m12, -m13,
 150                                            -m21, -m22, -m23,
 151                                            -m31, -m32, -m33);
 152         }
 153
 154         bool operator==(const matrix3& m) const
 155         {
 156                 return equals(m11,m.m11) && equals(m12,m.m12) && equals(m13,m.m13) &&
 157                            equals(m21,m.m21) && equals(m22,m.m22) && equals(m23,m.m23) &&
 158                            equals(m31,m.m31) && equals(m32,m.m32) && equals(m33,m.m33);
 159         }
 160         bool operator!=(const matrix3& m) const
 161         {
 162                 return !(*this == m);
 163         }
 164
 165
 166         union
 167         {
 168                 struct
 169                 {
 170                         scalar m11, m21, m31;
 171                         scalar m12, m22, m32;
 172                         scalar m13, m23, m33;   ///< scalars
 173                 };
 174                 scalar array[9];                        ///< array
 175         };
 176
 177         static matrix3 zero;                    ///< zero matrix
 178         static matrix3 identity;                ///< identity matrix
 179 };
 180
 181 inline matrix3 operator*(scalar s, const matrix3& m)
 182 {
 183         return m * s;
 184 }
 185 inline matrix3 operator/(scalar s, const matrix3& m)
 186 {
 187         return matrix3(s / m.m11, s / m.m12, s / m.m13,
 188                                    s / m.m21, s / m.m22, s / m.m23,
 189                                    s / m.m31, s / m.m32, s / m.m33);
 190 }
 191
 192
 193 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 194
 195 /**
 196  * 4x4 matrix.
 197  */
 198
 199 struct matrix4
 200 {
 201         matrix4() {}
 202         matrix4(scalar M11, scalar M12, scalar M13, scalar M14,
 203                         scalar M21, scalar M22, scalar M23, scalar M24,
 204                         scalar M31, scalar M32, scalar M33, scalar M34,
 205                         scalar M41, scalar M42, scalar M43, scalar M44)
 206         {
 207                 m11 = M11; m12 = M12; m13 = M13; m14 = M14;
 208                 m21 = M21; m22 = M22; m23 = M23; m24 = M24;
 209                 m31 = M31; m32 = M32; m33 = M33; m34 = M34;
 210                 m41 = M41; m42 = M42; m43 = M43; m44 = M44;
 211         }
 212         matrix4(scalar m[15])
 213         {
 214                 array[0] = m[0]; array[1] = m[1]; array[2] = m[2]; array[3] = m[3];
 215                 array[4] = m[4]; array[5] = m[5]; array[6] = m[6]; array[7] = m[7];
 216                 array[8] = m[8]; array[9] = m[9]; array[10] = m[10]; array[11] = m[11];
 217                 array[12] = m[12]; array[13] = m[13]; array[14] = m[14]; array[15] = m[15];
 218         }
 219
 220         const scalar& operator[](int i) const
 221         {
 222                 assert(i >= 0 && i <= 15 && "Index into matrix4 out of bounds.");
 223                 return array[i];
 224         }
 225         scalar& operator[](int i)
 226         {
 227                 assert(i >= 0 && i <= 15 && "Index into matrix4 out of bounds.");
 228                 return array[i];
 229         }
 230
 231         matrix4 operator+(const matrix4& m) const
 232         {
 233                 return matrix4(m11 + m.m11, m12 + m.m12, m13 + m.m13, m14 + m.m14,
 234                                            m21 + m.m21, m22 + m.m22, m23 + m.m23, m24 + m.m24,
 235                                            m31 + m.m31, m32 + m.m32, m33 + m.m33, m34 + m.m34,
 236                                            m41 + m.m41, m42 + m.m42, m43 + m.m43, m44 + m.m44);
 237         }
 238         matrix4 operator-(const matrix4& m) const
 239         {
 240                 return matrix4(m11 - m.m11, m12 - m.m12, m13 - m.m13, m14 - m.m14,
 241                                            m21 - m.m21, m22 - m.m22, m23 - m.m23, m24 - m.m24,
 242                                            m31 - m.m31, m32 - m.m32, m33 - m.m33, m34 - m.m34,
 243                                            m41 - m.m41, m42 - m.m42, m43 - m.m43, m44 - m.m44);
 244         }
 245         matrix4 operator*(const matrix4& m) const // TODO ??
 246         {
 247                 return matrix4(m11 * m.m11 + m12 * m.m21 + m13 * m.m31 + m14 * m.m41,
 248                                            m11 * m.m12 + m12 * m.m22 + m13 * m.m32 + m14 * m.m42,
 249                                            m11 * m.m13 + m12 * m.m23 + m13 * m.m33 + m14 * m.m43,
 250                                            m11 * m.m14 + m12 * m.m24 + m13 * m.m34 + m14 * m.m44,
 251                                            m21 * m.m11 + m22 * m.m21 + m23 * m.m31 + m24 * m.m41,
 252                                            m21 * m.m12 + m22 * m.m22 + m23 * m.m32 + m24 * m.m42,
 253                                            m21 * m.m13 + m22 * m.m23 + m23 * m.m33 + m24 * m.m43,
 254                                            m21 * m.m14 + m22 * m.m24 + m23 * m.m34 + m24 * m.m44,
 255                                            m31 * m.m11 + m32 * m.m21 + m33 * m.m31 + m34 * m.m41,
 256                                            m31 * m.m12 + m32 * m.m22 + m33 * m.m32 + m34 * m.m42,
 257                                            m31 * m.m13 + m32 * m.m23 + m33 * m.m33 + m34 * m.m43,
 258                                            m31 * m.m14 + m32 * m.m24 + m33 * m.m34 + m34 * m.m44,
 259                                            m41 * m.m11 + m42 * m.m21 + m43 * m.m31 + m44 * m.m41,
 260                                            m41 * m.m12 + m42 * m.m22 + m43 * m.m32 + m44 * m.m42,
 261                                            m41 * m.m13 + m42 * m.m23 + m43 * m.m33 + m44 * m.m43,
 262                                            m41 * m.m14 + m42 * m.m24 + m43 * m.m34 + m44 * m.m44);
 263         }
 264         matrix4 operator*(scalar s) const
 265         {
 266                 return matrix4(m11 * s, m12 * s, m13 * s, m14 * s,
 267                                            m21 * s, m22 * s, m23 * s, m24 * s,
 268                                            m31 * s, m32 * s, m33 * s, m34 * s,
 269                                            m41 * s, m42 * s, m43 * s, m44 * s);
 270         }
 271         matrix4 operator/(scalar s) const
 272         {
 273                 return matrix4(m11 / s, m12 / s, m13 / s, m14 / s,
 274                                            m21 / s, m22 / s, m23 / s, m24 / s,
 275                                            m31 / s, m32 / s, m33 / s, m34 / s,
 276                                            m41 / s, m42 / s, m43 / s, m44 / s);
 277         }
 278
 279         matrix4& operator+=(const matrix4& m)
 280         {
 281                 m11 += m.m11; m12 += m.m12; m13 += m.m13; m14 += m.m14;
 282                 m21 += m.m21; m22 += m.m22; m23 += m.m23; m24 += m.m24;
 283                 m31 += m.m31; m32 += m.m32; m33 += m.m33; m34 += m.m34;
 284                 m41 += m.m41; m42 += m.m42; m43 += m.m43; m44 += m.m44;
 285                 return *this;
 286         }
 287         matrix4& operator-=(const matrix4& m)
 288         {
 289                 m11 -= m.m11; m12 -= m.m12; m13 -= m.m13; m14 -= m.m14;
 290                 m21 -= m.m21; m22 -= m.m22; m23 -= m.m23; m24 -= m.m24;
 291                 m31 -= m.m31; m32 -= m.m32; m33 -= m.m33; m34 -= m.m34;
 292                 m41 -= m.m41; m42 -= m.m42; m43 -= m.m43; m44 -= m.m44;
 293                 return *this;
 294         }
 295         matrix4& operator*=(const matrix4& m)
 296         {
 297                 *this = *this * m;
 298                 return *this;
 299         }
 300         matrix4& operator*=(scalar s)
 301         {
 302                 m11 *= s; m12 *= s; m13 *= s; m14 *= s;
 303                 m21 *= s; m22 *= s; m23 *= s; m24 *= s;
 304                 m31 *= s; m32 *= s; m33 *= s; m34 *= s;
 305                 m41 *= s; m42 *= s; m43 *= s; m44 *= s;
 306                 return *this;
 307         }
 308         matrix4& operator/=(scalar s)
 309         {
 310                 m11 /= s; m12 /= s; m13 /= s; m14 /= s;
 311                 m21 /= s; m22 /= s; m23 /= s; m24 /= s;
 312                 m31 /= s; m32 /= s; m33 /= s; m34 /= s;
 313                 m41 /= s; m42 /= s; m43 /= s; m44 /= s;
 314                 return *this;
 315         }
 316
 317         matrix4 operator-() const
 318         {
 319                 return matrix4(-m11, -m12, -m13, -m14,
 320                                            -m21, -m22, -m23, -m24,
 321                                            -m31, -m32, -m33, -m34,
 322                                            -m41, -m42, -m43, -m44);
 323         }
 324
 325         bool operator==(const matrix4& m) const
 326         {
 327                 return equals(m11,m.m11) && equals(m12,m.m12) && equals(m13,m.m13) &&
 328                            equals(m14,m.m14) && equals(m21,m.m21) && equals(m22,m.m22) &&
 329                            equals(m23,m.m23) && equals(m24,m.m24) && equals(m31,m.m31) &&
 330                            equals(m32,m.m32) && equals(m33,m.m33) && equals(m34,m.m34) &&
 331                            equals(m41,m.m41) && equals(m42,m.m42) && equals(m43,m.m43) &&
 332                            equals(m44,m.m44);
 333         }
 334         bool operator!=(const matrix4& m) const
 335         {
 336                 return !(*this == m);
 337         }
 338
 339
 340         union
 341         {
 342                 struct
 343                 {
 344                         scalar m11, m21, m31, m41;
 345                         scalar m12, m22, m32, m42;
 346                         scalar m13, m23, m33, m43;
 347                         scalar m14, m24, m34, m44;      ///< scalars
 348                 };
 349                 scalar array[16];                               ///< array
 350         };
 351
 352         static matrix4 zero;                            ///< zero matrix
 353         static matrix4 identity;                        ///< identity matrix
 354 };
 355
 356 inline matrix4 operator*(scalar s, const matrix4& m)
 357 {
 358         return m * s;
 359 }
 360 inline matrix4 operator/(scalar s, const matrix4& m)
 361 {
 362         return matrix4(s / m.m11, s / m.m12, s / m.m13, s / m.m14,
 363                                    s / m.m21, s / m.m22, s / m.m23, s / m.m24,
 364                                    s / m.m31, s / m.m32, s / m.m33, s / m.m34,
 365                                    s / m.m41, s / m.m42, s / m.m43, s / m.m44);
 366 }
 367
 368
 369 } // namespace dc
 370
 371
 372 #endif // _MATRIX_HH_
 373