src/base/FBaseFloatMatrix4.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
  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        FBaseFloatMatrix4.cpp
  20  * @brief       This is the implementation for FloatMatrix class.
  21  */
  22
  23 #include <FBaseFloatMatrix4.h>
  24 #include <FBaseSysLog.h>
  25
  26 namespace Tizen { namespace Base
  27 {
  28
  29 static const int MATRIX_SIZE = sizeof(float) * 16;
  30 #define SWAP_VALUES(a, b, tmp) \
  31         tmp = a; \
  32         a = b; \
  33         b = tmp;
  34
  35 FloatMatrix4::FloatMatrix4(void)
  36         : __pImpl(null)
  37 {
  38         SetAsNull();
  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  // need to check performance
 128 {
 129         FloatMatrix4 resultMatrix;
 130
 131         resultMatrix.matrix[0][0] = matrix[0][0] * rhs.matrix[0][0] + matrix[0][1] * rhs.matrix[1][0] + matrix[0][2] * rhs.matrix[2][0] + matrix[0][3] * rhs.matrix[3][0];
 132         resultMatrix.matrix[0][1] = matrix[0][0] * rhs.matrix[0][1] + matrix[0][1] * rhs.matrix[1][1] + matrix[0][2] * rhs.matrix[2][1] + matrix[0][3] * rhs.matrix[3][1];
 133         resultMatrix.matrix[0][2] = matrix[0][0] * rhs.matrix[0][2] + matrix[0][1] * rhs.matrix[1][2] + matrix[0][2] * rhs.matrix[2][2] + matrix[0][3] * rhs.matrix[3][2];
 134         resultMatrix.matrix[0][3] = matrix[0][0] * rhs.matrix[0][3] + matrix[0][1] * rhs.matrix[1][3] + matrix[0][2] * rhs.matrix[2][3] + matrix[0][3] * rhs.matrix[3][3];
 135
 136         resultMatrix.matrix[1][0] = matrix[1][0] * rhs.matrix[0][0] + matrix[1][1] * rhs.matrix[1][0] + matrix[1][2] * rhs.matrix[2][0] + matrix[1][3] * rhs.matrix[3][0];
 137         resultMatrix.matrix[1][1] = matrix[1][0] * rhs.matrix[0][1] + matrix[1][1] * rhs.matrix[1][1] + matrix[1][2] * rhs.matrix[2][1] + matrix[1][3] * rhs.matrix[3][1];
 138         resultMatrix.matrix[1][2] = matrix[1][0] * rhs.matrix[0][2] + matrix[1][1] * rhs.matrix[1][2] + matrix[1][2] * rhs.matrix[2][2] + matrix[1][3] * rhs.matrix[3][2];
 139         resultMatrix.matrix[1][3] = matrix[1][0] * rhs.matrix[0][3] + matrix[1][1] * rhs.matrix[1][3] + matrix[1][2] * rhs.matrix[2][3] + matrix[1][3] * rhs.matrix[3][3];
 140
 141         resultMatrix.matrix[2][0] = matrix[2][0] * rhs.matrix[0][0] + matrix[2][1] * rhs.matrix[1][0] + matrix[2][2] * rhs.matrix[2][0] + matrix[2][3] * rhs.matrix[3][0];
 142         resultMatrix.matrix[2][1] = matrix[2][0] * rhs.matrix[0][1] + matrix[2][1] * rhs.matrix[1][1] + matrix[2][2] * rhs.matrix[2][1] + matrix[2][3] * rhs.matrix[3][1];
 143         resultMatrix.matrix[2][2] = matrix[2][0] * rhs.matrix[0][2] + matrix[2][1] * rhs.matrix[1][2] + matrix[2][2] * rhs.matrix[2][2] + matrix[2][3] * rhs.matrix[3][2];
 144         resultMatrix.matrix[2][3] = matrix[2][0] * rhs.matrix[0][3] + matrix[2][1] * rhs.matrix[1][3] + matrix[2][2] * rhs.matrix[2][3] + matrix[2][3] * rhs.matrix[3][3];
 145
 146         resultMatrix.matrix[3][0] = matrix[3][0] * rhs.matrix[0][0] + matrix[3][1] * rhs.matrix[1][0] + matrix[3][2] * rhs.matrix[2][0] + matrix[3][3] * rhs.matrix[3][0];
 147         resultMatrix.matrix[3][1] = matrix[3][0] * rhs.matrix[0][1] + matrix[3][1] * rhs.matrix[1][1] + matrix[3][2] * rhs.matrix[2][1] + matrix[3][3] * rhs.matrix[3][1];
 148         resultMatrix.matrix[3][2] = matrix[3][0] * rhs.matrix[0][2] + matrix[3][1] * rhs.matrix[1][2] + matrix[3][2] * rhs.matrix[2][2] + matrix[3][3] * rhs.matrix[3][2];
 149         resultMatrix.matrix[3][3] = matrix[3][0] * rhs.matrix[0][3] + matrix[3][1] * rhs.matrix[1][3] + matrix[3][2] * rhs.matrix[2][3] + matrix[3][3] * rhs.matrix[3][3];
 150
 151         return resultMatrix;
 152 }
 153
 154 FloatMatrix4
 155 FloatMatrix4::operator *(float value) const
 156 {
 157         FloatMatrix4 resultMatrix(matrix);
 158
 159         resultMatrix.matrix[0][0] *= value;
 160         resultMatrix.matrix[0][1] *= value;
 161         resultMatrix.matrix[0][2] *= value;
 162         resultMatrix.matrix[0][3] *= value;
 163
 164         resultMatrix.matrix[1][0] *= value;
 165         resultMatrix.matrix[1][1] *= value;
 166         resultMatrix.matrix[1][2] *= value;
 167         resultMatrix.matrix[1][3] *= value;
 168
 169         resultMatrix.matrix[2][0] *= value;
 170         resultMatrix.matrix[2][1] *= value;
 171         resultMatrix.matrix[2][2] *= value;
 172         resultMatrix.matrix[2][3] *= value;
 173
 174         resultMatrix.matrix[3][0] *= value;
 175         resultMatrix.matrix[3][1] *= value;
 176         resultMatrix.matrix[3][2] *= value;
 177         resultMatrix.matrix[3][3] *= value;
 178
 179         return resultMatrix;
 180 }
 181
 182 FloatMatrix4
 183 FloatMatrix4::operator +(const FloatMatrix4& rhs) const
 184 {
 185         FloatMatrix4 resultMatrix(matrix);
 186
 187         resultMatrix.matrix[0][0] += rhs.matrix[0][0];
 188         resultMatrix.matrix[0][1] += rhs.matrix[0][1];
 189         resultMatrix.matrix[0][2] += rhs.matrix[0][2];
 190         resultMatrix.matrix[0][3] += rhs.matrix[0][3];
 191
 192         resultMatrix.matrix[1][0] += rhs.matrix[1][0];
 193         resultMatrix.matrix[1][1] += rhs.matrix[1][1];
 194         resultMatrix.matrix[1][2] += rhs.matrix[1][2];
 195         resultMatrix.matrix[1][3] += rhs.matrix[1][3];
 196
 197         resultMatrix.matrix[2][0] += rhs.matrix[2][0];
 198         resultMatrix.matrix[2][1] += rhs.matrix[2][1];
 199         resultMatrix.matrix[2][2] += rhs.matrix[2][2];
 200         resultMatrix.matrix[2][3] += rhs.matrix[2][3];
 201
 202         resultMatrix.matrix[3][0] += rhs.matrix[3][0];
 203         resultMatrix.matrix[3][1] += rhs.matrix[3][1];
 204         resultMatrix.matrix[3][2] += rhs.matrix[3][2];
 205         resultMatrix.matrix[3][3] += rhs.matrix[3][3];
 206
 207         return resultMatrix;
 208 }
 209
 210 FloatMatrix4
 211 FloatMatrix4::operator +(float value) const
 212 {
 213         FloatMatrix4 resultMatrix(matrix);
 214
 215         resultMatrix.matrix[0][0] += value;
 216         resultMatrix.matrix[0][1] += value;
 217         resultMatrix.matrix[0][2] += value;
 218         resultMatrix.matrix[0][3] += value;
 219
 220         resultMatrix.matrix[1][0] += value;
 221         resultMatrix.matrix[1][1] += value;
 222         resultMatrix.matrix[1][2] += value;
 223         resultMatrix.matrix[1][3] += value;
 224
 225         resultMatrix.matrix[2][0] += value;
 226         resultMatrix.matrix[2][1] += value;
 227         resultMatrix.matrix[2][2] += value;
 228         resultMatrix.matrix[2][3] += value;
 229
 230         resultMatrix.matrix[3][0] += value;
 231         resultMatrix.matrix[3][1] += value;
 232         resultMatrix.matrix[3][2] += value;
 233         resultMatrix.matrix[3][3] += value;
 234
 235         return resultMatrix;
 236 }
 237
 238 FloatMatrix4
 239 FloatMatrix4::operator -(const FloatMatrix4& rhs) const
 240 {
 241         FloatMatrix4 resultMatrix(matrix);
 242
 243         resultMatrix.matrix[0][0] -= rhs.matrix[0][0];
 244         resultMatrix.matrix[0][1] -= rhs.matrix[0][1];
 245         resultMatrix.matrix[0][2] -= rhs.matrix[0][2];
 246         resultMatrix.matrix[0][3] -= rhs.matrix[0][3];
 247
 248         resultMatrix.matrix[1][0] -= rhs.matrix[1][0];
 249         resultMatrix.matrix[1][1] -= rhs.matrix[1][1];
 250         resultMatrix.matrix[1][2] -= rhs.matrix[1][2];
 251         resultMatrix.matrix[1][3] -= rhs.matrix[1][3];
 252
 253         resultMatrix.matrix[2][0] -= rhs.matrix[2][0];
 254         resultMatrix.matrix[2][1] -= rhs.matrix[2][1];
 255         resultMatrix.matrix[2][2] -= rhs.matrix[2][2];
 256         resultMatrix.matrix[2][3] -= rhs.matrix[2][3];
 257
 258         resultMatrix.matrix[3][0] -= rhs.matrix[3][0];
 259         resultMatrix.matrix[3][1] -= rhs.matrix[3][1];
 260         resultMatrix.matrix[3][2] -= rhs.matrix[3][2];
 261         resultMatrix.matrix[3][3] -= rhs.matrix[3][3];
 262
 263         return resultMatrix;
 264 }
 265
 266 FloatMatrix4
 267 FloatMatrix4::operator -(float value) const
 268 {
 269         FloatMatrix4 resultMatrix(matrix);
 270
 271         resultMatrix.matrix[0][0] -= value;
 272         resultMatrix.matrix[0][1] -= value;
 273         resultMatrix.matrix[0][2] -= value;
 274         resultMatrix.matrix[0][3] -= value;
 275
 276         resultMatrix.matrix[1][0] -= value;
 277         resultMatrix.matrix[1][1] -= value;
 278         resultMatrix.matrix[1][2] -= value;
 279         resultMatrix.matrix[1][3] -= value;
 280
 281         resultMatrix.matrix[2][0] -= value;
 282         resultMatrix.matrix[2][1] -= value;
 283         resultMatrix.matrix[2][2] -= value;
 284         resultMatrix.matrix[2][3] -= value;
 285
 286         resultMatrix.matrix[3][0] -= value;
 287         resultMatrix.matrix[3][1] -= value;
 288         resultMatrix.matrix[3][2] -= value;
 289         resultMatrix.matrix[3][3] -= value;
 290
 291         return resultMatrix;
 292 }
 293
 294 FloatMatrix4&
 295 FloatMatrix4::operator *=(const FloatMatrix4& rhs)
 296 {
 297         *this = *this * rhs;
 298         return *this;
 299 }
 300
 301 FloatMatrix4&
 302 FloatMatrix4::operator *=(float value)
 303 {
 304         *this = *this * value;
 305         return *this;
 306 }
 307
 308 FloatMatrix4&
 309 FloatMatrix4::operator +=(const FloatMatrix4& rhs)
 310 {
 311         *this = *this + rhs;
 312         return *this;
 313 }
 314
 315 FloatMatrix4&
 316 FloatMatrix4::operator +=(float value)
 317 {
 318         *this = *this + value;
 319         return *this;
 320 }
 321
 322 FloatMatrix4&
 323 FloatMatrix4::operator -=(const FloatMatrix4& rhs)
 324 {
 325         *this = *this - rhs;
 326         return *this;
 327 }
 328
 329 FloatMatrix4&
 330 FloatMatrix4::operator -=(float value)
 331 {
 332         *this = *this - value;
 333         return *this;
 334 }
 335
 336 FloatMatrix4
 337 operator +(const float& value, const FloatMatrix4& rhs)
 338 {
 339         return rhs + value;
 340 }
 341
 342 FloatMatrix4
 343 operator *(const float& value, const FloatMatrix4& rhs)
 344 {
 345         return rhs * value;
 346 }
 347
 348 FloatMatrix4
 349 operator -(const float& value, const FloatMatrix4& rhs)
 350 {
 351         FloatMatrix4 returnMatrix(rhs);
 352         returnMatrix.Negate();
 353         returnMatrix += value;
 354         return returnMatrix;
 355 }
 356
 357 bool
 358 FloatMatrix4::Equals(const Tizen::Base::Object& obj) const
 359 {
 360         const FloatMatrix4* pMatrix = dynamic_cast <const FloatMatrix4*>(&obj);
 361
 362         if (pMatrix == null)
 363         {
 364                 return false;
 365         }
 366
 367         return (*this == *pMatrix);
 368 }
 369
 370 int
 371 FloatMatrix4::GetHashCode(void) const
 372 {
 373         return (Tizen::Base::Float::GetHashCode(matrix[0][0]) + Tizen::Base::Float::GetHashCode(matrix[1][0]) +
 374                         Tizen::Base::Float::GetHashCode(matrix[2][0]) + Tizen::Base::Float::GetHashCode(matrix[3][0]) +
 375                         Tizen::Base::Float::GetHashCode(matrix[0][1]) + Tizen::Base::Float::GetHashCode(matrix[1][1]) +
 376                         Tizen::Base::Float::GetHashCode(matrix[2][1]) + Tizen::Base::Float::GetHashCode(matrix[3][1]) +
 377                         Tizen::Base::Float::GetHashCode(matrix[0][2]) + Tizen::Base::Float::GetHashCode(matrix[1][2]) +
 378                         Tizen::Base::Float::GetHashCode(matrix[2][2]) + Tizen::Base::Float::GetHashCode(matrix[3][2]) +
 379                         Tizen::Base::Float::GetHashCode(matrix[0][3]) + Tizen::Base::Float::GetHashCode(matrix[1][3]) +
 380                         Tizen::Base::Float::GetHashCode(matrix[2][3]) + Tizen::Base::Float::GetHashCode(matrix[3][3]));
 381 }
 382
 383 float
 384 FloatMatrix4::GetDeterminant(void) const
 385 {
 386         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 387         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 388         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 389         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 390         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 391         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 392
 393         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 394         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 395         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 396         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 397         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 398         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 399
 400         return a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 401 }
 402
 403 FloatMatrix4
 404 FloatMatrix4::GetInverse(void) const
 405 {
 406         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 407         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 408         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 409         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 410         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 411         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 412
 413         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 414         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 415         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 416         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 417         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 418         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 419
 420         float determinant = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 421
 422         if (Tizen::Base::Float::Compare(determinant, 0.0f) == 0)
 423         {
 424                 return *this;
 425         }
 426
 427         float inverseMatrix[4][4];
 428
 429         inverseMatrix[0][0] = (matrix[1][1] * b5 - matrix[1][2] * b4 + matrix[1][3] * b3) / determinant;
 430         inverseMatrix[1][0] = (-matrix[1][0] * b5 + matrix[1][2] * b2 - matrix[1][3] * b1) / determinant;
 431         inverseMatrix[2][0] = (matrix[1][0] * b4 - matrix[1][1] * b2 + matrix[1][3] * b0) / determinant;
 432         inverseMatrix[3][0] = (-matrix[1][0] * b3 + matrix[1][1] * b1 - matrix[1][2] * b0) / determinant;
 433
 434         inverseMatrix[0][1] = (-matrix[0][1] * b5 + matrix[0][2] * b4 - matrix[0][3] * b3) / determinant;
 435         inverseMatrix[1][1] = (matrix[0][0] * b5 - matrix[0][2] * b2 + matrix[0][3] * b1) / determinant;
 436         inverseMatrix[2][1] = (-matrix[0][0] * b4 + matrix[0][1] * b2 - matrix[0][3] * b0) / determinant;
 437         inverseMatrix[3][1] = (matrix[0][0] * b3 - matrix[0][1] * b1 + matrix[0][2] * b0) / determinant;
 438
 439         inverseMatrix[0][2] = (matrix[3][1] * a5 - matrix[3][2] * a4 + matrix[3][3] * a3) / determinant;
 440         inverseMatrix[1][2] = (-matrix[3][0] * a5 + matrix[3][2] * a2 - matrix[3][3] * a1) / determinant;
 441         inverseMatrix[2][2] = (matrix[3][0] * a4 - matrix[3][1] * a2 + matrix[3][3] * a0) / determinant;
 442         inverseMatrix[3][2] = (-matrix[3][0] * a3 + matrix[3][1] * a1 - matrix[3][2] * a0) / determinant;
 443
 444         inverseMatrix[0][3] = (-matrix[2][1] * a5 + matrix[2][2] * a4 - matrix[2][3] * a3) / determinant;
 445         inverseMatrix[1][3] = (matrix[2][0] * a5 - matrix[2][2] * a2 + matrix[2][3] * a1) / determinant;
 446         inverseMatrix[2][3] = (-matrix[2][0] * a4 + matrix[2][1] * a2 - matrix[2][3] * a0) / determinant;
 447         inverseMatrix[3][3] = (matrix[2][0] * a3 - matrix[2][1] * a1 + matrix[2][2] * a0) / determinant;
 448
 449         return FloatMatrix4(inverseMatrix);
 450 }
 451
 452 float
 453 FloatMatrix4::GetTrace(void) const
 454 {
 455         return matrix[0][0] + matrix[1][1] + matrix[2][2] + matrix[3][3];
 456 }
 457
 458 FloatMatrix4
 459 FloatMatrix4::GetTranspose(void) const
 460 {
 461         FloatMatrix4 transposeMatrix(matrix);
 462         transposeMatrix.Transpose();
 463
 464         return transposeMatrix;
 465 }
 466
 467 bool
 468 FloatMatrix4::IsIdentity(void) const
 469 {
 470         if ((Tizen::Base::Float::Compare(matrix[0][0], 1.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][1], 1.0f) != 0) ||
 471                 (Tizen::Base::Float::Compare(matrix[2][2], 1.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][3], 1.0f) != 0))
 472         {
 473                 return false;
 474         }
 475
 476         if ((Tizen::Base::Float::Compare(matrix[0][1], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[0][2], 0.0f) != 0) ||
 477                 (Tizen::Base::Float::Compare(matrix[0][3], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][0], 0.0f) != 0) ||
 478                 (Tizen::Base::Float::Compare(matrix[1][2], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[1][3], 0.0f) != 0) ||
 479                 (Tizen::Base::Float::Compare(matrix[2][0], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[2][1], 0.0f) != 0) ||
 480                 (Tizen::Base::Float::Compare(matrix[2][3], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][0], 0.0f) != 0) ||
 481                 (Tizen::Base::Float::Compare(matrix[3][1], 0.0f) != 0) || (Tizen::Base::Float::Compare(matrix[3][2], 0.0f) != 0))
 482         {
 483                 return false;
 484         }
 485
 486         return true;
 487 }
 488
 489 bool
 490 FloatMatrix4::IsInvertible(void) const
 491 {
 492         if (Tizen::Base::Float::Compare(GetDeterminant(), 0.0f) == 0)
 493         {
 494                 return false;
 495         }
 496
 497         return true;
 498 }
 499
 500 void
 501 FloatMatrix4::Negate(void)
 502 {
 503         matrix[0][0] = -matrix[0][0];
 504         matrix[0][1] = -matrix[0][1];
 505         matrix[0][2] = -matrix[0][2];
 506         matrix[0][3] = -matrix[0][3];
 507
 508         matrix[1][0] = -matrix[1][0];
 509         matrix[1][1] = -matrix[1][1];
 510         matrix[1][2] = -matrix[1][2];
 511         matrix[1][3] = -matrix[1][3];
 512
 513         matrix[2][0] = -matrix[2][0];
 514         matrix[2][1] = -matrix[2][1];
 515         matrix[2][2] = -matrix[2][2];
 516         matrix[2][3] = -matrix[2][3];
 517
 518         matrix[3][0] = -matrix[3][0];
 519         matrix[3][1] = -matrix[3][1];
 520         matrix[3][2] = -matrix[3][2];
 521         matrix[3][3] = -matrix[3][3];
 522 }
 523
 524 void
 525 FloatMatrix4::SetAsIdentity(void)
 526 {
 527         matrix[0][0] = 1.0f;
 528         matrix[0][1] = 0.0f;
 529         matrix[0][2] = 0.0f;
 530         matrix[0][3] = 0.0f;
 531
 532         matrix[1][0] = 0.0f;
 533         matrix[1][1] = 1.0f;
 534         matrix[1][2] = 0.0f;
 535         matrix[1][3] = 0.0f;
 536
 537         matrix[2][0] = 0.0f;
 538         matrix[2][1] = 0.0f;
 539         matrix[2][2] = 1.0f;
 540         matrix[2][3] = 0.0f;
 541
 542         matrix[3][0] = 0.0f;
 543         matrix[3][1] = 0.0f;
 544         matrix[3][2] = 0.0f;
 545         matrix[3][3] = 1.0f;
 546 }
 547
 548 result
 549 FloatMatrix4::Invert(void)
 550 {
 551         float a0 = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 552         float a1 = matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0];
 553         float a2 = matrix[0][0] * matrix[1][3] - matrix[0][3] * matrix[1][0];
 554         float a3 = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
 555         float a4 = matrix[0][1] * matrix[1][3] - matrix[0][3] * matrix[1][1];
 556         float a5 = matrix[0][2] * matrix[1][3] - matrix[0][3] * matrix[1][2];
 557
 558         float b0 = matrix[2][0] * matrix[3][1] - matrix[2][1] * matrix[3][0];
 559         float b1 = matrix[2][0] * matrix[3][2] - matrix[2][2] * matrix[3][0];
 560         float b2 = matrix[2][0] * matrix[3][3] - matrix[2][3] * matrix[3][0];
 561         float b3 = matrix[2][1] * matrix[3][2] - matrix[2][2] * matrix[3][1];
 562         float b4 = matrix[2][1] * matrix[3][3] - matrix[2][3] * matrix[3][1];
 563         float b5 = matrix[2][2] * matrix[3][3] - matrix[2][3] * matrix[3][2];
 564
 565         float determinant = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
 566
 567         SysTryReturnResult(NID_BASE, Tizen::Base::Float::Compare(determinant, 0.0f) != 0, E_INVALID_OPERATION, "The current instance is not invertible.");
 568
 569         float inverseMatrix[4][4];
 570
 571         inverseMatrix[0][0] = (matrix[1][1] * b5 - matrix[1][2] * b4 + matrix[1][3] * b3) / determinant;
 572         inverseMatrix[1][0] = (-matrix[1][0] * b5 + matrix[1][2] * b2 - matrix[1][3] * b1) / determinant;
 573         inverseMatrix[2][0] = (matrix[1][0] * b4 - matrix[1][1] * b2 + matrix[1][3] * b0) / determinant;
 574         inverseMatrix[3][0] = (-matrix[1][0] * b3 + matrix[1][1] * b1 - matrix[1][2] * b0) / determinant;
 575
 576         inverseMatrix[0][1] = (-matrix[0][1] * b5 + matrix[0][2] * b4 - matrix[0][3] * b3) / determinant;
 577         inverseMatrix[1][1] = (matrix[0][0] * b5 - matrix[0][2] * b2 + matrix[0][3] * b1) / determinant;
 578         inverseMatrix[2][1] = (-matrix[0][0] * b4 + matrix[0][1] * b2 - matrix[0][3] * b0) / determinant;
 579         inverseMatrix[3][1] = (matrix[0][0] * b3 - matrix[0][1] * b1 + matrix[0][2] * b0) / determinant;
 580
 581         inverseMatrix[0][2] = (matrix[3][1] * a5 - matrix[3][2] * a4 + matrix[3][3] * a3) / determinant;
 582         inverseMatrix[1][2] = (-matrix[3][0] * a5 + matrix[3][2] * a2 - matrix[3][3] * a1) / determinant;
 583         inverseMatrix[2][2] = (matrix[3][0] * a4 - matrix[3][1] * a2 + matrix[3][3] * a0) / determinant;
 584         inverseMatrix[3][2] = (-matrix[3][0] * a3 + matrix[3][1] * a1 - matrix[3][2] * a0) / determinant;
 585
 586         inverseMatrix[0][3] = (-matrix[2][1] * a5 + matrix[2][2] * a4 - matrix[2][3] * a3) / determinant;
 587         inverseMatrix[1][3] = (matrix[2][0] * a5 - matrix[2][2] * a2 + matrix[2][3] * a1) / determinant;
 588         inverseMatrix[2][3] = (-matrix[2][0] * a4 + matrix[2][1] * a2 - matrix[2][3] * a0) / determinant;
 589         inverseMatrix[3][3] = (matrix[2][0] * a3 - matrix[2][1] * a1 + matrix[2][2] * a0) / determinant;
 590
 591         memcpy(matrix, inverseMatrix, MATRIX_SIZE);
 592
 593         return E_SUCCESS;
 594 }
 595
 596 void
 597 FloatMatrix4::Transpose(void)
 598 {
 599         float tmp = 0.0f;
 600         SWAP_VALUES(matrix[0][1], matrix[1][0], tmp);
 601         SWAP_VALUES(matrix[0][2], matrix[2][0], tmp);
 602         SWAP_VALUES(matrix[0][3], matrix[3][0], tmp);
 603
 604         SWAP_VALUES(matrix[1][2], matrix[2][1], tmp);
 605         SWAP_VALUES(matrix[1][3], matrix[3][1], tmp);
 606
 607         SWAP_VALUES(matrix[2][3], matrix[3][2], tmp);
 608 }
 609
 610 void
 611 FloatMatrix4::SetAsNull(void)
 612 {
 613         matrix[0][0] = 0.0f;
 614         matrix[0][1] = 0.0f;
 615         matrix[0][2] = 0.0f;
 616         matrix[0][3] = 0.0f;
 617
 618         matrix[1][0] = 0.0f;
 619         matrix[1][1] = 0.0f;
 620         matrix[1][2] = 0.0f;
 621         matrix[1][3] = 0.0f;
 622
 623         matrix[2][0] = 0.0f;
 624         matrix[2][1] = 0.0f;
 625         matrix[2][2] = 0.0f;
 626         matrix[2][3] = 0.0f;
 627
 628         matrix[3][0] = 0.0f;
 629         matrix[3][1] = 0.0f;
 630         matrix[3][2] = 0.0f;
 631         matrix[3][3] = 0.0f;
 632 }
 633
 634 }} // Tizen::Base