Formatted API

[platform/core/uifw/dali-core.git] / dali / public-api / math / matrix3.cpp

diff --git a/dali/public-api/math/matrix3.cpp b/dali/public-api/math/matrix3.cpp
index 12adfcb..5fc44e7 100644 (file)
--- a/dali/public-api/math/matrix3.cpp
+++ b/dali/public-api/math/matrix3.cpp
@@ -44,16 +44,13 @@
 
 namespace
 {
-const uint32_t NUM_BYTES_IN_ROW    = 3*sizeof(float);
-const uint32_t NUM_BYTES_IN_MATRIX = 9*sizeof(float);
-}
+const uint32_t NUM_BYTES_IN_ROW    = 3 * sizeof(float);
+const uint32_t NUM_BYTES_IN_MATRIX = 9 * sizeof(float);
+} // namespace
 
 namespace Dali
 {
-
-const Matrix3 Matrix3::IDENTITY(1.0f, 0.0f, 0.0f,
-                                0.0f, 1.0f, 0.0f,
-                                0.0f, 0.0f, 1.0f);
+const Matrix3 Matrix3::IDENTITY(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 
 Matrix3::Matrix3()
 {
@@ -63,15 +60,15 @@ Matrix3::Matrix3()
 
 Matrix3::Matrix3(const Matrix3& m)
 {
-  memcpy( mElements, m.mElements, NUM_BYTES_IN_MATRIX );
+  memcpy(mElements, m.mElements, NUM_BYTES_IN_MATRIX);
 }
 
 Matrix3::Matrix3(const Matrix& matrix)
 {
   const float* m4 = matrix.AsFloat();
-  memcpy(&mElements[S00], m4,   NUM_BYTES_IN_ROW);
-  memcpy(&mElements[S10], m4+4, NUM_BYTES_IN_ROW);
-  memcpy(&mElements[S20], m4+8, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S10], m4 + 4, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S20], m4 + 8, NUM_BYTES_IN_ROW);
 }
 
 Matrix3::Matrix3(float s00, float s01, float s02, float s10, float s11, float s12, float s20, float s21, float s22)
@@ -87,45 +84,44 @@ Matrix3::Matrix3(float s00, float s01, float s02, float s10, float s11, float s1
   mElements[S22] = s22;
 }
 
-
 void Matrix3::SetIdentity()
 {
   memset(mElements, 0, NUM_BYTES_IN_MATRIX);
-  mElements[S00]=1.0f;
-  mElements[S11]=1.0f;
-  mElements[S22]=1.0f;
+  mElements[S00] = 1.0f;
+  mElements[S11] = 1.0f;
+  mElements[S22] = 1.0f;
 }
 
-Matrix3::Matrix3( Matrix3&& matrix )
+Matrix3::Matrix3(Matrix3&& matrix)
 {
-  memcpy( mElements, matrix.mElements, NUM_BYTES_IN_MATRIX );
+  memcpy(mElements, matrix.mElements, NUM_BYTES_IN_MATRIX);
 }
 
-Matrix3& Matrix3::operator=( Matrix3&& matrix )
+Matrix3& Matrix3::operator=(Matrix3&& matrix)
 {
-  if( this != &matrix )
+  if(this != &matrix)
   {
-    memcpy( AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX );
+    memcpy(AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX);
   }
   return *this;
 }
 
-Matrix3& Matrix3::operator=( const Matrix3& matrix )
+Matrix3& Matrix3::operator=(const Matrix3& matrix)
 {
   // no point copying if self assigning
-  if( this != &matrix )
+  if(this != &matrix)
   {
-    memcpy( AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX );
+    memcpy(AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX);
   }
   return *this;
 }
 
-Matrix3& Matrix3::operator=( const Matrix& matrix )
+Matrix3& Matrix3::operator=(const Matrix& matrix)
 {
   const float* m4 = matrix.AsFloat();
-  memcpy(&mElements[S00], m4,   NUM_BYTES_IN_ROW);
-  memcpy(&mElements[S10], m4+4, NUM_BYTES_IN_ROW);
-  memcpy(&mElements[S20], m4+8, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S10], m4 + 4, NUM_BYTES_IN_ROW);
+  memcpy(&mElements[S20], m4 + 8, NUM_BYTES_IN_ROW);
   return *this;
 }
 
@@ -149,10 +145,10 @@ bool Matrix3::Invert()
   float det = mElements[S00] * cof[S00] + mElements[S01] * cof[S10] + mElements[S02] * cof[S20];
 
   // In the case where the determinant is exactly zero, the matrix is non-invertible
-  if( ! EqualsZero( det ) )
+  if(!EqualsZero(det))
   {
     det = 1.0f / det;
-    for( int32_t i = 0; i < 9; i++ )
+    for(int32_t i = 0; i < 9; i++)
     {
       mElements[i] = cof[i] * det;
     }
@@ -164,9 +160,15 @@ bool Matrix3::Invert()
 bool Matrix3::Transpose()
 {
   float tmp;
-  tmp = mElements[S01]; mElements[S01] = mElements[S10]; mElements[S10]=tmp;
-  tmp = mElements[S02]; mElements[S02] = mElements[S20]; mElements[S20]=tmp;
-  tmp = mElements[S21]; mElements[S21] = mElements[S12]; mElements[S12]=tmp;
+  tmp            = mElements[S01];
+  mElements[S01] = mElements[S10];
+  mElements[S10] = tmp;
+  tmp            = mElements[S02];
+  mElements[S02] = mElements[S20];
+  mElements[S20] = tmp;
+  tmp            = mElements[S21];
+  mElements[S21] = mElements[S12];
+  mElements[S12] = tmp;
   return true;
 }
 
@@ -190,16 +192,16 @@ bool Matrix3::ScaledInverseTranspose()
   float det = mElements[S00] * cof[S00] + mElements[S01] * cof[S10] + mElements[S02] * cof[S20];
 
   // In the case where the determinant is exactly zero, the matrix is non-invertible
-  if( ! EqualsZero( det ) )
+  if(!EqualsZero(det))
   {
     // Use average rather than determinant to remove rounding to zero errors in further multiplication
-    float sum=0;
-    for(uint32_t i=0;i<9;i++)
+    float sum = 0;
+    for(uint32_t i = 0; i < 9; i++)
     {
-      sum+=fabsf(cof[i]);
+      sum += fabsf(cof[i]);
     }
-    float scale = 9.0f/sum; // Inverse of the average values
-    if (det < 0)
+    float scale = 9.0f / sum; // Inverse of the average values
+    if(det < 0)
     {
       // Ensure the signs of the inverse are correct
       scale = -scale;
@@ -237,33 +239,32 @@ void Matrix3::Scale(float scale)
 
 float Matrix3::Magnitude() const
 {
-  float avg=0;
-  for(uint32_t i=0;i<9;i++)
+  float avg = 0;
+  for(uint32_t i = 0; i < 9; i++)
   {
-    avg+=fabsf(mElements[i]);
+    avg += fabsf(mElements[i]);
   }
-  return avg/3.0f;
+  return avg / 3.0f;
 }
 
-
-void Matrix3::Multiply( Matrix3& result, const Matrix3& lhs, const Matrix3& rhs )
+void Matrix3::Multiply(Matrix3& result, const Matrix3& lhs, const Matrix3& rhs)
 {
-  float* temp = result.AsFloat();
-  const float* rhsPtr  = rhs.AsFloat();
+  float*       temp   = result.AsFloat();
+  const float* rhsPtr = rhs.AsFloat();
   const float* lhsPtr = lhs.AsFloat();
 
-  for( int32_t i=0; i < 3; i++ )
+  for(int32_t i = 0; i < 3; i++)
   {
-    int32_t loc = i * 3;
+    int32_t loc  = i * 3;
     int32_t loc1 = loc + 1;
     int32_t loc2 = loc + 2;
 
     float value0 = lhsPtr[loc];
     float value1 = lhsPtr[loc1];
     float value2 = lhsPtr[loc2];
-    temp[loc]  = (value0 * rhsPtr[0]) +
-                 (value1 * rhsPtr[3]) +
-                 (value2 * rhsPtr[6]);
+    temp[loc]    = (value0 * rhsPtr[0]) +
+                (value1 * rhsPtr[3]) +
+                (value2 * rhsPtr[6]);
 
     temp[loc1] = (value0 * rhsPtr[1]) +
                  (value1 * rhsPtr[4]) +
@@ -275,18 +276,18 @@ void Matrix3::Multiply( Matrix3& result, const Matrix3& lhs, const Matrix3& rhs
   }
 }
 
-bool Matrix3::operator==(const Matrix3 & rhs) const
+bool Matrix3::operator==(const Matrix3& rhs) const
 {
   return (
-    Equals( mElements[0], rhs.mElements[0]) &&
-    Equals( mElements[1], rhs.mElements[1]) &&
-    Equals( mElements[2], rhs.mElements[2]) &&
-    Equals( mElements[3], rhs.mElements[3]) &&
-    Equals( mElements[4], rhs.mElements[4]) &&
-    Equals( mElements[5], rhs.mElements[5]) &&
-    Equals( mElements[6], rhs.mElements[6]) &&
-    Equals( mElements[7], rhs.mElements[7]) &&
-    Equals( mElements[8], rhs.mElements[8]));
+    Equals(mElements[0], rhs.mElements[0]) &&
+    Equals(mElements[1], rhs.mElements[1]) &&
+    Equals(mElements[2], rhs.mElements[2]) &&
+    Equals(mElements[3], rhs.mElements[3]) &&
+    Equals(mElements[4], rhs.mElements[4]) &&
+    Equals(mElements[5], rhs.mElements[5]) &&
+    Equals(mElements[6], rhs.mElements[6]) &&
+    Equals(mElements[7], rhs.mElements[7]) &&
+    Equals(mElements[8], rhs.mElements[8]));
 }
 
 bool Matrix3::operator!=(const Matrix3& rhs) const
@@ -294,11 +295,11 @@ bool Matrix3::operator!=(const Matrix3& rhs) const
   return !(*this == rhs);
 }
 
-std::ostream& operator<< (std::ostream& o, const Matrix3& matrix)
+std::ostream& operator<<(std::ostream& o, const Matrix3& matrix)
 {
   return o << "[ " << matrix.mElements[0] << ", " << matrix.mElements[1] << ", " << matrix.mElements[2] << ", "
-                   << matrix.mElements[3] << ", " << matrix.mElements[4] << ", " << matrix.mElements[5] << ", "
-                   << matrix.mElements[6] << ", " << matrix.mElements[7] << ", " << matrix.mElements[8] << " ]";
+           << matrix.mElements[3] << ", " << matrix.mElements[4] << ", " << matrix.mElements[5] << ", "
+           << matrix.mElements[6] << ", " << matrix.mElements[7] << ", " << matrix.mElements[8] << " ]";
 }
 
 } // namespace Dali