src/graphics/FGrpFloatMatrix4.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file        FGrpFloatMatrix4.cpp
  20  * @brief       This is the implementation for FloatMatrix class.
  21  */
  22
  23 #include <FGrpFloatMatrix4.h>
  24 #include <FGrpFloatVector4.h>
  25 #include <FBaseFloat.h>
  26 #include <FBaseSysLog.h>
  27
  28
  29 namespace Tizen { namespace Graphics
  30 {
  31
  32 static const int MATRIX_SIZE = sizeof(float) * 16;
  33 #define SWAP_VALUES(a, b, tmp) tmp = a; a = b; b = tmp;
  34
  35 FloatMatrix4::FloatMatrix4(void)
  36         : __pImpl(null)
  37 {
  38         SetAsIdentity();
  39 }
  40
  41 FloatMatrix4::FloatMatrix4(const FloatMatrix4& rhs)
  42         : __pImpl(null)
  43 {
  44         memcpy(matrix, rhs.matrix, MATRIX_SIZE);
  45 }
  46
  47 FloatMatrix4::FloatMatrix4(const float matrix[4][4])
  48         : __pImpl(null)
  49 {
  50         memcpy(this->matrix, matrix, MATRIX_SIZE);
  51 }
  52
  53 FloatMatrix4::~FloatMatrix4(void)
  54 {
  55 }
  56
  57 bool
  58 FloatMatrix4::operator ==(const FloatMatrix4& rhs) const
  59 {
  60         if (this == &rhs)
  61         {
  62                 return true;
  63         }
  64
  65         return (matrix[0][0] == rhs.matrix[0][0] &&
  66                         matrix[0][1] == rhs.matrix[0][1] &&
  67                         matrix[0][2] == rhs.matrix[0][2] &&
  68                         matrix[0][3] == rhs.matrix[0][3] &&
  69                         matrix[1][0] == rhs.matrix[1][0] &&
  70                         matrix[1][1] == rhs.matrix[1][1] &&
  71                         matrix[1][2] == rhs.matrix[1][2] &&
  72                         matrix[1][3] == rhs.matrix[1][3] &&
  73                         matrix[2][0] == rhs.matrix[2][0] &&
  74                         matrix[2][1] == rhs.matrix[2][1] &&
  75                         matrix[2][2] == rhs.matrix[2][2] &&
  76                         matrix[2][3] == rhs.matrix[2][3] &&
  77                         matrix[3][0] == rhs.matrix[3][0] &&
  78                         matrix[3][1] == rhs.matrix[3][1] &&
  79                         matrix[3][2] == rhs.matrix[3][2] &&
  80                         matrix[3][3] == rhs.matrix[3][3]);
  81 }
  82
  83 bool
  84 FloatMatrix4::operator !=(const FloatMatrix4& rhs) const
  85 {
  86         return !(*this == rhs);
  87 }
  88
  89 FloatMatrix4&
  90 FloatMatrix4::operator =(const FloatMatrix4& rhs)
  91 {
  92         if (this != &rhs)
  93         {
  94                 memcpy(matrix, rhs.matrix, MATRIX_SIZE);
  95         }
  96
  97         return *this;
  98 }
  99
 100 FloatMatrix4&
 101 FloatMatrix4::operator =(float value)
 102 {
 103         matrix[0][0] = value;
 104         matrix[1][0] = value;
 105         matrix[2][0] = value;
 106         matrix[3][0] = value;
 107
 108         matrix[0][1] = value;
 109         matrix[1][1] = value;
 110         matrix[2][1] = value;
 111         matrix[3][1] = value;
 112
 113         matrix[0][2] = value;
 114         matrix[1][2] = value;
 115         matrix[2][2] = value;
 116         matrix[3][2] = value;
 117
 118         matrix[0][3] = value;
 119         matrix[1][3] = value;
 120         matrix[2][3] = value;
 121         matrix[3][3] = value;
 122
 123         return *this;
 124 }
 125
 126 FloatMatrix4
 127 FloatMatrix4::operator *(const FloatMatrix4& rhs) const
 128 {
 129         FloatMatrix4 resultMatrix;
 130
 131         resultMatrix.matrix[0][0] = (this->matrix[0][0] * rhs.matrix[0][0]) +
 132                           (this->matrix[1][0] * rhs.matrix[0][1]) +
 133                           (this->matrix[2][0] * rhs.matrix[0][2]) +
 134                           (this->matrix[3][0] * rhs.matrix[0][3]);
 135         resultMatrix.matrix[1][0] = (this->matrix[0][0] * rhs.matrix[1][0]) +
 136                           (this->matrix[1][0] * rhs.matrix[1][1]) +
 137                           (this->matrix[2][0] * rhs.matrix[1][2]) +
 138                           (this->matrix[3][0] * rhs.matrix[1][3]);
 139         resultMatrix.matrix[2][0] = (this->matrix[0][0] * rhs.matrix[2][0]) +
 140                           (this->matrix[1][0] * rhs.matrix[2][1]) +
 141                           (this->matrix[2][0] * rhs.matrix[2][2]) +
 142                           (this->matrix[3][0] * rhs.matrix[2][3]);
 143         resultMatrix.matrix[3][0] = (this->matrix[0][0] * rhs.matrix[3][0]) +
 144                           (this->matrix[1][0] * rhs.matrix[3][1]) +
 145                           (this->matrix[2][0] * rhs.matrix[3][2]) +
 146                           (this->matrix[3][0] * rhs.matrix[3][3]);
 147
 148         resultMatrix.matrix[0][1] = (this->matrix[0][1] * rhs.matrix[0][0]) +
 149                           (this->matrix[1][1] * rhs.matrix[0][1]) +
 150                           (this->matrix[2][1] * rhs.matrix[0][2]) +
 151                           (this->matrix[3][1] * rhs.matrix[0][3]);
 152         resultMatrix.matrix[1][1] = (this->matrix[0][1] * rhs.matrix[1][0]) +
 153                           (this->matrix[1][1] * rhs.matrix[1][1]) +
 154                           (this->matrix[2][1] * rhs.matrix[1][2]) +
 155                           (this->matrix[3][1] * rhs.matrix[1][3]);
 156         resultMatrix.matrix[2][1] = (this->matrix[0][1] * rhs.matrix[2][0]) +
 157                           (this->matrix[1][1] * rhs.matrix[2][1]) +
 158                           (this->matrix[2][1] * rhs.matrix[2][2]) +
 159                           (this->matrix[3][1] * rhs.matrix[2][3]);
 160         resultMatrix.matrix[3][1] = (this->matrix[0][1] * rhs.matrix[3][0]) +
 161                           (this->matrix[1][1] * rhs.matrix[3][1]) +
 162                           (this->matrix[2][1] * rhs.matrix[3][2]) +
 163                           (this->matrix[3][1] * rhs.matrix[3][3]);
 164
 165         resultMatrix.matrix[0][2] = (this->matrix[0][2] * rhs.matrix[0][0]) +
 166                           (this->matrix[1][2] * rhs.matrix[0][1]) +
 167                           (this->matrix[2][2] * rhs.matrix[0][2]) +
 168                           (this->matrix[3][2] * rhs.matrix[0][3]);
 169         resultMatrix.matrix[1][2] = (this->matrix[0][2] * rhs.matrix[1][0]) +
 170                           (this->matrix[1][2] * rhs.matrix[1][1]) +
 171                           (this->matrix[2][2] * rhs.matrix[1][2]) +
 172                           (this->matrix[3][2] * rhs.matrix[1][3]);
 173         resultMatrix.matrix[2][2] = (this->matrix[0][2] * rhs.matrix[2][0]) +
 174                           (this->matrix[1][2] * rhs.matrix[2][1]) +
 175                           (this->matrix[2][2] * rhs.matrix[2][2]) +
 176                           (this->matrix[3][2] * rhs.matrix[2][3]);
 177         resultMatrix.matrix[3][2] = (this->matrix[0][2] * rhs.matrix[3][0]) +
 178                           (this->matrix[1][2] * rhs.matrix[3][1]) +
 179                           (this->matrix[2][2] * rhs.matrix[3][2]) +
 180                           (this->matrix[3][2] * rhs.matrix[3][3]);
 181
 182         resultMatrix.matrix[0][3] = (this->matrix[0][3] * rhs.matrix[0][0]) +
 183                           (this->matrix[1][3] * rhs.matrix[0][1]) +
 184                           (this->matrix[2][3] * rhs.matrix[0][2]) +
 185                           (this->matrix[3][3] * rhs.matrix[0][3]);
 186         resultMatrix.matrix[1][3] = (this->matrix[0][3] * rhs.matrix[1][0]) +
 187                           (this->matrix[1][3] * rhs.matrix[1][1]) +
 188                           (this->matrix[2][3] * rhs.matrix[1][2]) +
 189                           (this->matrix[3][3] * rhs.matrix[1][3]);
 190         resultMatrix.matrix[2][3] = (this->matrix[0][3] * rhs.matrix[2][0]) +
 191                           (this->matrix[1][3] * rhs.matrix[2][1]) +
 192                           (this->matrix[2][3] * rhs.matrix[2][2]) +
 193                           (this->matrix[3][3] * rhs.matrix[2][3]);
 194         resultMatrix.matrix[3][3] = (this->matrix[0][3] * rhs.matrix[3][0]) +
 195                           (this->matrix[1][3] * rhs.matrix[3][1]) +
 196                           (this->matrix[2][3] * rhs.matrix[3][2]) +
 197                           (this->matrix[3][3] * rhs.matrix[3][3]);
 198
 199         return resultMatrix;
 200 }
 201
 202 FloatVector4
 203 FloatMatrix4::operator *(const FloatVector4& vector) const
 204 {
 205         FloatVector4 resultVector;
 206
 207         resultVector.x = (matrix[0][0] * vector.x) + (matrix[1][0] * vector.y) +
 208                         (matrix[2][0] * vector.z) + (matrix[3][0] * vector.w);
 209         resultVector.y = (matrix[0][1] * vector.x) + (matrix[1][1] * vector.y) +
 210                         (matrix[2][1] * vector.z) + (matrix[3][1] * vector.w);
 211         resultVector.z = (matrix[0][2] * vector.x) + (matrix[1][2] * vector.y) +
 212                         (matrix[2][2] * vector.z) + (matrix[3][2] * vector.w);
 213         resultVector.w = (matrix[0][3] * vector.x) + (matrix[1][3] * vector.y) +
 214                         (matrix[2][3] * vector.z) + (matrix[3][3] * vector.w);
 215
 216         return resultVector;
 217 }
 218
 219 FloatMatrix4
 220 FloatMatrix4::operator *(float value) const
 221 {
 222         FloatMatrix4 resultMatrix(matrix);
 223
 224         resultMatrix.matrix[0][0] *= value;
 225         resultMatrix.matrix[0][1] *= value;
 226         resultMatrix.matrix[0][2] *= value;
 227         resultMatrix.matrix[0][3] *= value;
 228
 229         resultMatrix.matrix[1][0] *= value;
 230         resultMatrix.matrix[1][1] *= value;
 231         resultMatrix.matrix[1][2] *= value;
 232         resultMatrix.matrix[1][3] *= value;
 233
 234         resultMatrix.matrix[2][0] *= value;
 235         resultMatrix.matrix[2][1] *= value;
 236         resultMatrix.matrix[2][2] *= value;
 237         resultMatrix.matrix[2][3] *= value;
 238
 239         resultMatrix.matrix[3][0] *= value;
 240         resultMatrix.matrix[3][1] *= value;
 241         resultMatrix.matrix[3][2] *= value;
 242         resultMatrix.matrix[3][3] *= value;
 243
 244         return resultMatrix;
 245 }
 246
 247 FloatMatrix4
 248 FloatMatrix4::operator +(const FloatMatrix4& rhs) const
 249 {
 250         FloatMatrix4 resultMatrix(matrix);
 251
 252         resultMatrix.matrix[0][0] += rhs.matrix[0][0];
 253         resultMatrix.matrix[0][1] += rhs.matrix[0][1];
 254         resultMatrix.matrix[0][2] += rhs.matrix[0][2];
 255         resultMatrix.matrix[0][3] += rhs.matrix[0][3];
 256
 257         resultMatrix.matrix[1][0] += rhs.matrix[1][0];
 258         resultMatrix.matrix[1][1] += rhs.matrix[1][1];
 259         resultMatrix.matrix[1][2] += rhs.matrix[1][2];
 260         resultMatrix.matrix[1][3] += rhs.matrix[1][3];
 261
 262         resultMatrix.matrix[2][0] += rhs.matrix[2][0];
 263         resultMatrix.matrix[2][1] += rhs.matrix[2][1];
 264         resultMatrix.matrix[2][2] += rhs.matrix[2][2];
 265         resultMatrix.matrix[2][3] += rhs.matrix[2][3];
 266
 267         resultMatrix.matrix[3][0] += rhs.matrix[3][0];
 268         resultMatrix.matrix[3][1] += rhs.matrix[3][1];
 269         resultMatrix.matrix[3][2] += rhs.matrix[3][2];
 270         resultMatrix.matrix[3][3] += rhs.matrix[3][3];
 271
 272         return resultMatrix;
 273 }
 274
 275 FloatMatrix4
 276 FloatMatrix4::operator +(float value) const
 277 {
 278         FloatMatrix4 resultMatrix(matrix);
 279
 280         resultMatrix.matrix[0][0] += value;
 281         resultMatrix.matrix[0][1] += value;
 282         resultMatrix.matrix[0][2] += value;
 283         resultMatrix.matrix[0][3] += value;
 284
 285         resultMatrix.matrix[1][0] += value;
 286         resultMatrix.matrix[1][1] += value;
 287         resultMatrix.matrix[1][2] += value;
 288         resultMatrix.matrix[1][3] += value;
 289
 290         resultMatrix.matrix[2][0] += value;
 291         resultMatrix.matrix[2][1] += value;
 292         resultMatrix.matrix[2][2] += value;
 293         resultMatrix.matrix[2][3] += value;
 294
 295         resultMatrix.matrix[3][0] += value;
 296         resultMatrix.matrix[3][1] += value;
 297         resultMatrix.matrix[3][2] += value;
 298         resultMatrix.matrix[3][3] += value;
 299
 300         return resultMatrix;
 301 }
 302
 303 FloatMatrix4
 304 FloatMatrix4::operator -(const FloatMatrix4& rhs) const
 305 {
 306         FloatMatrix4 resultMatrix(matrix);
 307
 308         resultMatrix.matrix[0][0] -= rhs.matrix[0][0];
 309         resultMatrix.matrix[0][1] -= rhs.matrix[0][1];
 310         resultMatrix.matrix[0][2] -= rhs.matrix[0][2];
 311         resultMatrix.matrix[0][3] -= rhs.matrix[0][3];
 312
 313         resultMatrix.matrix[1][0] -= rhs.matrix[1][0];
 314         resultMatrix.matrix[1][1] -= rhs.matrix[1][1];
 315         resultMatrix.matrix[1][2] -= rhs.matrix[1][2];
 316         resultMatrix.matrix[1][3] -= rhs.matrix[1][3];
 317
 318         resultMatrix.matrix[2][0] -= rhs.matrix[2][0];
 319         resultMatrix.matrix[2][1] -= rhs.matrix[2][1];
 320         resultMatrix.matrix[2][2] -= rhs.matrix[2][2];
 321         resultMatrix.matrix[2][3] -= rhs.matrix[2][3];
 322
 323         resultMatrix.matrix[3][0] -= rhs.matrix[3][0];
 324         resultMatrix.matrix[3][1] -= rhs.matrix[3][1];
 325         resultMatrix.matrix[3][2] -= rhs.matrix[3][2];
 326         resultMatrix.matrix[3][3] -= rhs.matrix[3][3];
 327
 328         return resultMatrix;
 329 }
 330
 331 FloatMatrix4
 332 FloatMatrix4::operator -(float value) const
 333 {
 334         FloatMatrix4 resultMatrix(matrix);
 335
 336         resultMatrix.matrix[0][0] -= value;
 337         resultMatrix.matrix[0][1] -= value;
 338         resultMatrix.matrix[0][2] -= value;
 339         resultMatrix.matrix[0][3] -= value;
 340
 341         resultMatrix.matrix[1][0] -= value;
 342         resultMatrix.matrix[1][1] -= value;
 343         resultMatrix.matrix[1][2] -= value;
 344         resultMatrix.matrix[1][3] -= value;
 345
 346         resultMatrix.matrix[2][0] -= value;
 347         resultMatrix.matrix[2][1] -= value;
 348         resultMatrix.matrix[2][2] -= value;
 349         resultMatrix.matrix[2][3] -= value;
 350
 351         resultMatrix.matrix[3][0] -= value;
 352         resultMatrix.matrix[3][1] -= value;
 353         resultMatrix.matrix[3][2] -= value;
 354         resultMatrix.matrix[3][3] -= value;
 355
 356         return resultMatrix;
 357 }
 358
 359 FloatMatrix4&
 360 FloatMatrix4::operator *=(const FloatMatrix4& rhs)
 361 {
 362         *this = *this * rhs;
 363         return *this;
 364 }
 365
 366 FloatMatrix4&
 367 FloatMatrix4::operator *=(float value)
 368 {
 369         *this = *this * value;
 370         return *this;
 371 }
 372
 373 FloatMatrix4&
 374 FloatMatrix4::operator +=(const FloatMatrix4& rhs)
 375 {
 376         *this = *this + rhs;
 377         return *this;
 378 }
 379
 380 FloatMatrix4&
 381 FloatMatrix4::operator +=(float value)
 382 {
 383         *this = *this + value;
 384         return *this;
 385 }
 386
 387 FloatMatrix4&
 388 FloatMatrix4::operator -=(const FloatMatrix4& rhs)
 389 {
 390         *this = *this - rhs;
 391         return *this;
 392 }
 393
 394 FloatMatrix4&
 395 FloatMatrix4::operator -=(float value)
 396 {
 397         *this = *this - value;
 398         return *this;
 399 }
 400
 401 FloatMatrix4
 402 operator +(const float& value, const FloatMatrix4& rhs)
 403 {
 404         return rhs + value;
 405 }
 406
 407 FloatMatrix4
 408 operator *(const float& value, const FloatMatrix4& rhs)
 409 {
 410         return rhs * value;
 411 }
 412
 413 FloatMatrix4
 414 operator -(const float& value, const FloatMatrix4& rhs)
 415 {
 416         FloatMatrix4 returnMatrix(rhs);
 417         returnMatrix.Negate();
 418         returnMatrix += value;
 419         return returnMatrix;
 420 }
 421
 422 bool
 423 FloatMatrix4::Equals(const Tizen::Base::Object& obj) const
 424 {
 425         const FloatMatrix4* pMatrix = dynamic_cast <const FloatMatrix4*>(&obj);
 426
 427         if (pMatrix == null)
 428         {
 429                 return false;
 430         }
 431
 432         return (*this == *pMatrix);
 433 }
 434
 435 int
 436 FloatMatrix4::GetHashCode(void) const
 437 {
 438         return (Tizen::Base::Float::GetHashCode(matrix[0][0]) + Tizen::Base::Float::GetHashCode(matrix[1][0]) +
 439                         Tizen::Base::Float::GetHashCode(matrix[2][0]) + Tizen::Base::Float::GetHashCode(matrix[3][0]) +
 440                         Tizen::Base::Float::GetHashCode(matrix[0][1]) + Tizen::Base::Float::GetHashCode(matrix[1][1]) +
 441                         Tizen::Base::Float::GetHashCode(matrix[2][1]) + Tizen::Base::Float::GetHashCode(matrix[3][1]) +
 442                         Tizen::Base::Float::GetHashCode(matrix[0][2]) + Tizen::Base::Float::GetHashCode(matrix[1][2]) +
 443                         Tizen::Base::Float::GetHashCode(matrix[2][2]) + Tizen::Base::Float::GetHashCode(matrix[3][2]) +
 444                         Tizen::Base::Float::GetHashCode(matrix[0][3]) + Tizen::Base::Float::GetHashCode(matrix[1][3]) +
 445                         Tizen::Base::Float::GetHashCode(matrix[2][3]) + Tizen::Base::Float::GetHashCode(matrix[3][3]));
 446 }
 447
 448 float
 449 FloatMatrix4::GetDeterminant(void) const
 450 {
 451         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 452         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 453         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 454         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 455         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 456         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 457
 458         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 459         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 460         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 461         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 462         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 463         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 464
 465         return a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 466 }
 467
 468 FloatMatrix4
 469 FloatMatrix4::GetInverse(void) const
 470 {
 471         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 472         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 473         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 474         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 475         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 476         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 477
 478         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 479         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 480         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 481         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 482         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 483         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 484
 485         float determinant = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 486
 487         if (Tizen::Base::Float::Compare(determinant, 0.0f) == 0)
 488         {
 489                 return *this;
 490         }
 491
 492         float inverseMatrix[4][4];
 493
 494         inverseMatrix[0][0] = (matrix[1][1] * b5 - matrix[1][2] * b4 + matrix[1][3] * b3) / determinant;
 495         inverseMatrix[1][0] = (-matrix[1][0] * b5 + matrix[1][2] * b2 - matrix[1][3] * b1) / determinant;
 496         inverseMatrix[2][0] = (matrix[1][0] * b4 - matrix[1][1] * b2 + matrix[1][3] * b0) / determinant;
 497         inverseMatrix[3][0] = (-matrix[1][0] * b3 + matrix[1][1] * b1 - matrix[1][2] * b0) / determinant;
 498
 499         inverseMatrix[0][1] = (-matrix[0][1] * b5 + matrix[0][2] * b4 - matrix[0][3] * b3) / determinant;
 500         inverseMatrix[1][1] = (matrix[0][0] * b5 - matrix[0][2] * b2 + matrix[0][3] * b1) / determinant;
 501         inverseMatrix[2][1] = (-matrix[0][0] * b4 + matrix[0][1] * b2 - matrix[0][3] * b0) / determinant;
 502         inverseMatrix[3][1] = (matrix[0][0] * b3 - matrix[0][1] * b1 + matrix[0][2] * b0) / determinant;
 503
 504         inverseMatrix[0][2] = (matrix[3][1] * a5 - matrix[3][2] * a4 + matrix[3][3] * a3) / determinant;
 505         inverseMatrix[1][2] = (-matrix[3][0] * a5 + matrix[3][2] * a2 - matrix[3][3] * a1) / determinant;
 506         inverseMatrix[2][2] = (matrix[3][0] * a4 - matrix[3][1] * a2 + matrix[3][3] * a0) / determinant;
 507         inverseMatrix[3][2] = (-matrix[3][0] * a3 + matrix[3][1] * a1 - matrix[3][2] * a0) / determinant;
 508
 509         inverseMatrix[0][3] = (-matrix[2][1] * a5 + matrix[2][2] * a4 - matrix[2][3] * a3) / determinant;
 510         inverseMatrix[1][3] = (matrix[2][0] * a5 - matrix[2][2] * a2 + matrix[2][3] * a1) / determinant;
 511         inverseMatrix[2][3] = (-matrix[2][0] * a4 + matrix[2][1] * a2 - matrix[2][3] * a0) / determinant;
 512         inverseMatrix[3][3] = (matrix[2][0] * a3 - matrix[2][1] * a1 + matrix[2][2] * a0) / determinant;
 513
 514         return FloatMatrix4(inverseMatrix);
 515 }
 516
 517 float
 518 FloatMatrix4::GetTrace(void) const
 519 {
 520         return matrix[0][0] + matrix[1][1] + matrix[2][2] + matrix[3][3];
 521 }
 522
 523 FloatMatrix4
 524 FloatMatrix4::GetTranspose(void) const
 525 {
 526         FloatMatrix4 transposeMatrix(matrix);
 527         transposeMatrix.Transpose();
 528
 529         return transposeMatrix;
 530 }
 531
 532 bool
 533 FloatMatrix4::IsIdentity(void) const
 534 {
 535         if ((Tizen::Base::Float::Compare(matrix[0][0], 1.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][1], 1.0f) != 0) ||
 536                 (Tizen::Base::Float::Compare(matrix[2][2], 1.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][3], 1.0f) != 0))
 537         {
 538                 return false;
 539         }
 540
 541         if ((Tizen::Base::Float::Compare(matrix[0][1], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[0][2], 0.0f) != 0) ||
 542                 (Tizen::Base::Float::Compare(matrix[0][3], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][0], 0.0f) != 0) ||
 543                 (Tizen::Base::Float::Compare(matrix[1][2], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][3], 0.0f) != 0) ||
 544                 (Tizen::Base::Float::Compare(matrix[2][0], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[2][1], 0.0f) != 0) ||
 545                 (Tizen::Base::Float::Compare(matrix[2][3], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][0], 0.0f) != 0) ||
 546                 (Tizen::Base::Float::Compare(matrix[3][1], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][2], 0.0f) != 0))
 547         {
 548                 return false;
 549         }
 550
 551         return true;
 552 }
 553
 554 bool
 555 FloatMatrix4::IsInvertible(void) const
 556 {
 557         if (Tizen::Base::Float::Compare(GetDeterminant(), 0.0f) == 0)
 558         {
 559                 return false;
 560         }
 561
 562         return true;
 563 }
 564
 565 void
 566 FloatMatrix4::Negate(void)
 567 {
 568         matrix[0][0] = -matrix[0][0];
 569         matrix[0][1] = -matrix[0][1];
 570         matrix[0][2] = -matrix[0][2];
 571         matrix[0][3] = -matrix[0][3];
 572
 573         matrix[1][0] = -matrix[1][0];
 574         matrix[1][1] = -matrix[1][1];
 575         matrix[1][2] = -matrix[1][2];
 576         matrix[1][3] = -matrix[1][3];
 577
 578         matrix[2][0] = -matrix[2][0];
 579         matrix[2][1] = -matrix[2][1];
 580         matrix[2][2] = -matrix[2][2];
 581         matrix[2][3] = -matrix[2][3];
 582
 583         matrix[3][0] = -matrix[3][0];
 584         matrix[3][1] = -matrix[3][1];
 585         matrix[3][2] = -matrix[3][2];
 586         matrix[3][3] = -matrix[3][3];
 587 }
 588
 589 void
 590 FloatMatrix4::SetAsIdentity(void)
 591 {
 592         matrix[0][0] = 1.0f;
 593         matrix[0][1] = 0.0f;
 594         matrix[0][2] = 0.0f;
 595         matrix[0][3] = 0.0f;
 596
 597         matrix[1][0] = 0.0f;
 598         matrix[1][1] = 1.0f;
 599         matrix[1][2] = 0.0f;
 600         matrix[1][3] = 0.0f;
 601
 602         matrix[2][0] = 0.0f;
 603         matrix[2][1] = 0.0f;
 604         matrix[2][2] = 1.0f;
 605         matrix[2][3] = 0.0f;
 606
 607         matrix[3][0] = 0.0f;
 608         matrix[3][1] = 0.0f;
 609         matrix[3][2] = 0.0f;
 610         matrix[3][3] = 1.0f;
 611 }
 612
 613 result
 614 FloatMatrix4::Invert(void)
 615 {
 616         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 617         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 618         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 619         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 620         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 621         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 622
 623         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 624         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 625         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 626         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 627         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 628         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 629
 630         float determinant = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 631
 632         SysTryReturnResult(NID_GRP, Tizen::Base::Float::Compare(determinant, 0.0f) != 0, E_INVALID_OPERATION, "The current instance is not invertible.");
 633
 634         float inverseMatrix[4][4];
 635
 636         inverseMatrix[0][0] = (matrix[1][1] * b5 - matrix[1][2] * b4 + matrix[1][3] * b3) / determinant;
 637         inverseMatrix[1][0] = (-matrix[1][0] * b5 + matrix[1][2] * b2 - matrix[1][3] * b1) / determinant;
 638         inverseMatrix[2][0] = (matrix[1][0] * b4 - matrix[1][1] * b2 + matrix[1][3] * b0) / determinant;
 639         inverseMatrix[3][0] = (-matrix[1][0] * b3 + matrix[1][1] * b1 - matrix[1][2] * b0) / determinant;
 640
 641         inverseMatrix[0][1] = (-matrix[0][1] * b5 + matrix[0][2] * b4 - matrix[0][3] * b3) / determinant;
 642         inverseMatrix[1][1] = (matrix[0][0] * b5 - matrix[0][2] * b2 + matrix[0][3] * b1) / determinant;
 643         inverseMatrix[2][1] = (-matrix[0][0] * b4 + matrix[0][1] * b2 - matrix[0][3] * b0) / determinant;
 644         inverseMatrix[3][1] = (matrix[0][0] * b3 - matrix[0][1] * b1 + matrix[0][2] * b0) / determinant;
 645
 646         inverseMatrix[0][2] = (matrix[3][1] * a5 - matrix[3][2] * a4 + matrix[3][3] * a3) / determinant;
 647         inverseMatrix[1][2] = (-matrix[3][0] * a5 + matrix[3][2] * a2 - matrix[3][3] * a1) / determinant;
 648         inverseMatrix[2][2] = (matrix[3][0] * a4 - matrix[3][1] * a2 + matrix[3][3] * a0) / determinant;
 649         inverseMatrix[3][2] = (-matrix[3][0] * a3 + matrix[3][1] * a1 - matrix[3][2] * a0) / determinant;
 650
 651         inverseMatrix[0][3] = (-matrix[2][1] * a5 + matrix[2][2] * a4 - matrix[2][3] * a3) / determinant;
 652         inverseMatrix[1][3] = (matrix[2][0] * a5 - matrix[2][2] * a2 + matrix[2][3] * a1) / determinant;
 653         inverseMatrix[2][3] = (-matrix[2][0] * a4 + matrix[2][1] * a2 - matrix[2][3] * a0) / determinant;
 654         inverseMatrix[3][3] = (matrix[2][0] * a3 - matrix[2][1] * a1 + matrix[2][2] * a0) / determinant;
 655
 656         memcpy(matrix, inverseMatrix, MATRIX_SIZE);
 657
 658         return E_SUCCESS;
 659 }
 660
 661 void
 662 FloatMatrix4::Transpose(void)
 663 {
 664         float tmp = 0.0f;
 665         SWAP_VALUES(matrix[0][1], matrix[1][0], tmp);
 666         SWAP_VALUES(matrix[0][2], matrix[2][0], tmp);
 667         SWAP_VALUES(matrix[0][3], matrix[3][0], tmp);
 668
 669         SWAP_VALUES(matrix[1][2], matrix[2][1], tmp);
 670         SWAP_VALUES(matrix[1][3], matrix[3][1], tmp);
 671
 672         SWAP_VALUES(matrix[2][3], matrix[3][2], tmp);
 673 }
 674
 675 void
 676 FloatMatrix4::SetAsNull(void)
 677 {
 678         matrix[0][0] = 0.0f;
 679         matrix[0][1] = 0.0f;
 680         matrix[0][2] = 0.0f;
 681         matrix[0][3] = 0.0f;
 682
 683         matrix[1][0] = 0.0f;
 684         matrix[1][1] = 0.0f;
 685         matrix[1][2] = 0.0f;
 686         matrix[1][3] = 0.0f;
 687
 688         matrix[2][0] = 0.0f;
 689         matrix[2][1] = 0.0f;
 690         matrix[2][2] = 0.0f;
 691         matrix[2][3] = 0.0f;
 692
 693         matrix[3][0] = 0.0f;
 694         matrix[3][1] = 0.0f;
 695         matrix[3][2] = 0.0f;
 696         matrix[3][3] = 0.0f;
 697 }
 698
 699 }} // Tizen::Graphics