src/base/FBaseFloatMatrix4.cpp

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