src/ui/inc/FUi_Matrix3Df.h

   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                FUi_Matrix3Df.h
  20  * @brief               Header file of _Matrix3Df class
  21  *
  22  * This file contains declarations _Matrix3Df class.
  23  */
  24
  25 #ifndef _FUI_ANIM_INTERNAL_MATRIX3DF_H_
  26 #define _FUI_ANIM_INTERNAL_MATRIX3DF_H_
  27
  28 #include <FOspCompat.h>
  29
  30 namespace Tizen { namespace Ui { namespace Animations
  31 {
  32
  33 class _Matrix3Df
  34 {
  35 public:
  36         enum
  37         {
  38                 IdentityMatrix = 0x0001,
  39                 TranslationMatrix = 0x0002,
  40                 ScaleMatrix = 0x0004,
  41                 GenericMatrix = 0x0008
  42         };
  43
  44         _Matrix3Df(void);
  45         _Matrix3Df(const _Matrix3Df& rhs)
  46         {
  47                 memcpy(__m, rhs.__m, sizeof(__m));
  48                 __complexity = rhs.__complexity;
  49         }
  50
  51         explicit _Matrix3Df(const float* pValues);
  52
  53         _Matrix3Df& Assign(const _Matrix3Df& rhs);
  54
  55         bool operator ==(const _Matrix3Df& rhs) const;
  56         bool operator !=(const _Matrix3Df& rhs) const;
  57         _Matrix3Df& operator =(const _Matrix3Df& rhs);
  58         _Matrix3Df& operator *=(const _Matrix3Df& rhs);
  59
  60         friend _Matrix3Df operator *(const _Matrix3Df& matrix1, const _Matrix3Df& matrix2);
  61
  62         void Optimize(void);
  63         bool IsIdentity(void) const { return __complexity == IdentityMatrix;}
  64         bool IsTranslation(void) const { return __complexity == TranslationMatrix;}
  65         bool IsScale(void) const { return __complexity == ScaleMatrix;}
  66         bool IsGeneric(void) const { return __complexity == GenericMatrix;}
  67
  68         void LoadIdentity(void);
  69         void Transpose(void);
  70
  71         _Matrix3Df& MultiplyMatrix(const _Matrix3Df& matrix);
  72         _Matrix3Df& Concatenate(const _Matrix3Df* matrix);
  73         _Matrix3Df& Concatenate(const _Matrix3Df& matrix);
  74
  75         float GetDeterminant(void) const;
  76         bool IsInvertible(void) const;
  77         bool Invert(void);
  78
  79         void Translate(float x, float y, float z);
  80         void Shear(float xy, float yz, float zx, float yx, float zy, float xz);
  81         void Scale(float sx, float sy, float sz);
  82         void Rotate(float angle, float x, float y, float z);
  83         void MakeOrthogonal(float left, float right, float bottom, float top, float n, float f);
  84         void MakeFrustum(float left, float right, float bottom, float top, float n, float f);
  85         void MakePerspective(float fovy, float aspect, float nearZ, float farZ);
  86         void MakeLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ);
  87         _Matrix3Df& MakeTransformAtAnchor(float x, float y, float z);
  88         float Normalize(void);
  89         void Transform(float* pX, float* pY, float* pZ) const;
  90
  91         float operator ()(int row, int col) const { return __m[col][row];}
  92         float GetItem(int row, int col) const { return __m[col][row];}
  93         void SetItem(int row, int col, float value) { __m[col][row] = value; __complexity = GenericMatrix; }
  94
  95         const float* GetItems(void) const { return __m[0];}
  96
  97 protected:
  98         float __m[4][4];    // column-major order (for OpenGL awareness...)
  99         int __complexity;   // for performance optimization. Most operations will be done with identity matrix.
 100 };      // _Matrix3Df
 101
 102
 103 inline _Matrix3Df
 104 operator *(const _Matrix3Df& matrix1, const _Matrix3Df& matrix2)
 105 {
 106         if (matrix1.__complexity == _Matrix3Df::IdentityMatrix)
 107                 return matrix2;
 108
 109         if (matrix2.__complexity == _Matrix3Df::IdentityMatrix)
 110                 return matrix1;
 111
 112
 113         if (matrix1.__complexity == _Matrix3Df::TranslationMatrix)
 114         {
 115                 if (matrix2.__complexity == _Matrix3Df::TranslationMatrix)
 116                 {
 117                         _Matrix3Df ret;
 118
 119                         ret.__m[3][0] = matrix2.__m[3][0] + matrix1.__m[3][0] * matrix2.__m[3][3];
 120                         ret.__m[3][1] = matrix2.__m[3][1] + matrix1.__m[3][1] * matrix2.__m[3][3];
 121                         ret.__m[3][2] = matrix2.__m[3][2] + matrix1.__m[3][2] * matrix2.__m[3][3];
 122                         ret.__m[3][3] = matrix1.__m[3][3] * matrix2.__m[3][3];
 123
 124                         ret.__complexity = _Matrix3Df::TranslationMatrix;
 125
 126                         return ret;
 127                 }
 128         }
 129
 130         /* TODO: Can be optimized more cases....?? (scale??) */
 131
 132
 133         /* Optimization with loop-unrolling.. really effective for this case ??? */
 134         float m[4][4];
 135
 136         m[0][0] = (matrix1.__m[0][0] * matrix2.__m[0][0]) +
 137                           (matrix1.__m[1][0] * matrix2.__m[0][1]) +
 138                           (matrix1.__m[2][0] * matrix2.__m[0][2]) +
 139                           (matrix1.__m[3][0] * matrix2.__m[0][3]);
 140         m[1][0] = (matrix1.__m[0][0] * matrix2.__m[1][0]) +
 141                           (matrix1.__m[1][0] * matrix2.__m[1][1]) +
 142                           (matrix1.__m[2][0] * matrix2.__m[1][2]) +
 143                           (matrix1.__m[3][0] * matrix2.__m[1][3]);
 144         m[2][0] = (matrix1.__m[0][0] * matrix2.__m[2][0]) +
 145                           (matrix1.__m[1][0] * matrix2.__m[2][1]) +
 146                           (matrix1.__m[2][0] * matrix2.__m[2][2]) +
 147                           (matrix1.__m[3][0] * matrix2.__m[2][3]);
 148         m[3][0] = (matrix1.__m[0][0] * matrix2.__m[3][0]) +
 149                           (matrix1.__m[1][0] * matrix2.__m[3][1]) +
 150                           (matrix1.__m[2][0] * matrix2.__m[3][2]) +
 151                           (matrix1.__m[3][0] * matrix2.__m[3][3]);
 152
 153         m[0][1] = (matrix1.__m[0][1] * matrix2.__m[0][0]) +
 154                           (matrix1.__m[1][1] * matrix2.__m[0][1]) +
 155                           (matrix1.__m[2][1] * matrix2.__m[0][2]) +
 156                           (matrix1.__m[3][1] * matrix2.__m[0][3]);
 157         m[1][1] = (matrix1.__m[0][1] * matrix2.__m[1][0]) +
 158                           (matrix1.__m[1][1] * matrix2.__m[1][1]) +
 159                           (matrix1.__m[2][1] * matrix2.__m[1][2]) +
 160                           (matrix1.__m[3][1] * matrix2.__m[1][3]);
 161         m[2][1] = (matrix1.__m[0][1] * matrix2.__m[2][0]) +
 162                           (matrix1.__m[1][1] * matrix2.__m[2][1]) +
 163                           (matrix1.__m[2][1] * matrix2.__m[2][2]) +
 164                           (matrix1.__m[3][1] * matrix2.__m[2][3]);
 165         m[3][1] = (matrix1.__m[0][1] * matrix2.__m[3][0]) +
 166                           (matrix1.__m[1][1] * matrix2.__m[3][1]) +
 167                           (matrix1.__m[2][1] * matrix2.__m[3][2]) +
 168                           (matrix1.__m[3][1] * matrix2.__m[3][3]);
 169
 170         m[0][2] = (matrix1.__m[0][2] * matrix2.__m[0][0]) +
 171                           (matrix1.__m[1][2] * matrix2.__m[0][1]) +
 172                           (matrix1.__m[2][2] * matrix2.__m[0][2]) +
 173                           (matrix1.__m[3][2] * matrix2.__m[0][3]);
 174         m[1][2] = (matrix1.__m[0][2] * matrix2.__m[1][0]) +
 175                           (matrix1.__m[1][2] * matrix2.__m[1][1]) +
 176                           (matrix1.__m[2][2] * matrix2.__m[1][2]) +
 177                           (matrix1.__m[3][2] * matrix2.__m[1][3]);
 178         m[2][2] = (matrix1.__m[0][2] * matrix2.__m[2][0]) +
 179                           (matrix1.__m[1][2] * matrix2.__m[2][1]) +
 180                           (matrix1.__m[2][2] * matrix2.__m[2][2]) +
 181                           (matrix1.__m[3][2] * matrix2.__m[2][3]);
 182         m[3][2] = (matrix1.__m[0][2] * matrix2.__m[3][0]) +
 183                           (matrix1.__m[1][2] * matrix2.__m[3][1]) +
 184                           (matrix1.__m[2][2] * matrix2.__m[3][2]) +
 185                           (matrix1.__m[3][2] * matrix2.__m[3][3]);
 186
 187         m[0][3] = (matrix1.__m[0][3] * matrix2.__m[0][0]) +
 188                           (matrix1.__m[1][3] * matrix2.__m[0][1]) +
 189                           (matrix1.__m[2][3] * matrix2.__m[0][2]) +
 190                           (matrix1.__m[3][3] * matrix2.__m[0][3]);
 191         m[1][3] = (matrix1.__m[0][3] * matrix2.__m[1][0]) +
 192                           (matrix1.__m[1][3] * matrix2.__m[1][1]) +
 193                           (matrix1.__m[2][3] * matrix2.__m[1][2]) +
 194                           (matrix1.__m[3][3] * matrix2.__m[1][3]);
 195         m[2][3] = (matrix1.__m[0][3] * matrix2.__m[2][0]) +
 196                           (matrix1.__m[1][3] * matrix2.__m[2][1]) +
 197                           (matrix1.__m[2][3] * matrix2.__m[2][2]) +
 198                           (matrix1.__m[3][3] * matrix2.__m[2][3]);
 199         m[3][3] = (matrix1.__m[0][3] * matrix2.__m[3][0]) +
 200                           (matrix1.__m[1][3] * matrix2.__m[3][1]) +
 201                           (matrix1.__m[2][3] * matrix2.__m[3][2]) +
 202                           (matrix1.__m[3][3] * matrix2.__m[3][3]);
 203
 204         return _Matrix3Df((const float*)m);
 205 }
 206
 207 class _Matrix3DfTr
 208         : public _Matrix3Df
 209 {
 210 public:
 211         _Matrix3DfTr(float tx, float ty, float tz)
 212         {
 213                 SetItem(0, 3, tx);
 214                 SetItem(1, 3, ty);
 215                 SetItem(2, 3, tz);
 216                 __complexity = TranslationMatrix;
 217         }
 218
 219         _Matrix3DfTr(const _Matrix3DfTr& rhs)
 220         {
 221                 Assign(rhs);
 222         }
 223 };      // _Matrix3DfTr
 224
 225 class _Matrix3DfRot
 226         : public _Matrix3Df
 227 {
 228 public:
 229         _Matrix3DfRot(float angle, float x, float y, float z)
 230         {
 231                 Rotate(angle, x, y, z);
 232                 __complexity = GenericMatrix;
 233         }
 234
 235         _Matrix3DfRot(const _Matrix3DfRot& rhs)
 236         {
 237                 Assign(rhs);
 238         }
 239 };      // _Matrix3DfRot
 240
 241 }}}     // Tizen::Ui::Animations
 242
 243 #endif  //_FUI_ANIM_INTERNAL_MATRIX3DF_H_
 244