src/ui/effects/inc/renderer/math/FUiEffects_RendererMathVector.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       FUiEffects_RendererMathVector.h
  20  * @brief      The Vector class
  21  *
  22  */
  23
  24 #ifndef _FUI_EFFECTS_INTERNAL_RENDERER_MATH_VECTOR_H_
  25 #define _FUI_EFFECTS_INTERNAL_RENDERER_MATH_VECTOR_H_
  26
  27 #include <renderer/system/FUiEffects_RendererSystemStaticAssert.h>
  28
  29 #include <renderer/math/FUiEffects_RendererMathVector1Traits.h>
  30 #include <renderer/math/FUiEffects_RendererMathVector2Traits.h>
  31 #include <renderer/math/FUiEffects_RendererMathVector3Traits.h>
  32 #include <renderer/math/FUiEffects_RendererMathCommon.h>
  33 #include <renderer/math/FUiEffects_RendererMathAdapterFunctions.h>
  34
  35 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace Math
  36 {
  37
  38 template<typename T, int Dimension>
  39 class Vector :
  40         public VectorTraits<T, Dimension>
  41 {
  42 public:
  43         typedef Vector<T, Dimension> VectorType;
  44         typedef VectorTraitsBase<T, Dimension> VectorTraitsBaseType;
  45         typedef typename VectorTraitsBaseType::TypeReference TypeReference;
  46
  47         using VectorTraitsBaseType::data;
  48         using VectorTraits<T, Dimension>::Set;
  49
  50         inline Vector(void);
  51         inline explicit Vector(const TypeReference value);
  52         inline Vector(const TypeReference x, const TypeReference y);
  53         inline Vector(const TypeReference x, const TypeReference y, const TypeReference z);
  54         inline Vector(const TypeReference x, const TypeReference y, const TypeReference z, const TypeReference w);
  55         inline Vector(const VectorType& other);
  56
  57         inline VectorType& operator = (const VectorType& rhv);
  58
  59         inline VectorType& Set(const VectorType& other);
  60         inline VectorType& Set(const TypeReference value);
  61
  62         inline VectorType& FillFromArray(const T* array);
  63         static inline VectorType MakeFromArray(const T* array);
  64
  65         inline VectorType operator - (void) const;
  66         inline VectorType& Inverse(void);
  67         inline VectorType GetInversed(void) const;
  68
  69         inline VectorType& operator += (const VectorType& rhv);
  70         inline VectorType& operator += (const TypeReference rhv);
  71         inline VectorType& operator -= (const VectorType& rhv);
  72         inline VectorType& operator -= (const TypeReference rhv);
  73         inline VectorType& operator *= (const VectorType& rhv);
  74         inline VectorType& operator *= (const TypeReference rhv);
  75         inline VectorType& operator /= (const VectorType& rhv);
  76         inline VectorType& operator /= (const TypeReference rhv);
  77
  78         inline T* GetPointer(void);
  79         inline const T* GetPointer(void) const;
  80
  81         inline VectorType& Normalize(void);
  82         inline VectorType GetNormalized(void) const;
  83
  84         inline VectorType& Lerp(const VectorType& to, const TypeReference coeff);
  85         inline VectorType GetLerped(const VectorType& to, const TypeReference) const;
  86         inline VectorType& MakeLerped(const VectorType& from, const VectorType& to, const TypeReference);
  87         static inline VectorType CreateLerped(const VectorType& from, const VectorType& to, const TypeReference);
  88
  89         inline T Dot(const VectorType& other) const;
  90
  91         inline T LengthSqr(void) const;
  92         inline T Length(void) const;
  93         inline T DistanceSqr(const VectorType& other) const;
  94         inline T Distance(const VectorType& other) const;
  95
  96         inline Vector<T, 2> Swizzle(unsigned int x, unsigned int y) const;
  97         inline Vector<T, 3> Swizzle(unsigned int x, unsigned int y, unsigned int z) const;
  98         inline Vector<T, 4> Swizzle(unsigned int x, unsigned int y, unsigned int z, unsigned int w) const;
  99
 100         inline bool IsEqual(const Vector<T, Dimension>& rhv, const TypeReference epsilon = EffectsEpsilon<T>::epsilon()) const;
 101 };
 102
 103 template<typename T, int Dimension>
 104 inline bool IsEqual(const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv, const typename Vector<T, Dimension>::TypeReference epsilon);
 105
 106 template<typename T, int Dimension> inline Vector<T, Dimension> operator + (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 107 template<typename T, int Dimension> inline Vector<T, Dimension> operator + (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 108 template<typename T, int Dimension> inline Vector<T, Dimension> operator + (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 109 template<typename T, int Dimension> inline Vector<T, Dimension> operator - (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 110 template<typename T, int Dimension> inline Vector<T, Dimension> operator - (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 111 template<typename T, int Dimension> inline Vector<T, Dimension> operator - (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 112 template<typename T, int Dimension> inline Vector<T, Dimension> operator * (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 113 template<typename T, int Dimension> inline Vector<T, Dimension> operator * (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 114 template<typename T, int Dimension> inline Vector<T, Dimension> operator * (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 115 template<typename T, int Dimension> inline Vector<T, Dimension> operator / (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 116 template<typename T, int Dimension> inline Vector<T, Dimension> operator / (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 117 template<typename T, int Dimension> inline Vector<T, Dimension> operator / (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 118 template<typename T, int Dimension> inline bool operator == (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 119 template<typename T, int Dimension> inline bool operator == (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 120 template<typename T, int Dimension> inline bool operator == (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 121 template<typename T, int Dimension> inline bool operator != (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv);
 122 template<typename T, int Dimension> inline bool operator != (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv);
 123 template<typename T, int Dimension> inline bool operator != (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv);
 124
 125 typedef Vector<float, 1> Vector1f;
 126 typedef Vector<double, 1> Vector1d;
 127 typedef Vector<float, 2> Vector2f;
 128 typedef Vector<double, 2> Vector2d;
 129 typedef Vector<float, 3> Vector3f;
 130 typedef Vector<double, 3> Vector3d;
 131 typedef Vector<float, 4> Vector4f;
 132 typedef Vector<double, 4> Vector4d;
 133
 134 template<typename T, int Dimension>
 135 Vector<T, Dimension>::Vector(void)
 136 {
 137 }
 138
 139 template<typename T, int Dimension>
 140 Vector<T, Dimension>::Vector(const TypeReference value)
 141 {
 142         for (int i = 0; i < Dimension; i++)
 143         {
 144                 data[i] = value;
 145         }
 146 }
 147
 148 template<typename T, int Dimension>
 149 Vector<T, Dimension>::Vector(const TypeReference x, const TypeReference y)
 150 {
 151         EffectsStaticAssert(Dimension >= 2);
 152         data[0] = x;
 153         data[1] = y;
 154 }
 155
 156 template<typename T, int Dimension>
 157 Vector<T, Dimension>::Vector(const TypeReference x, const TypeReference y, const TypeReference z)
 158 {
 159         EffectsStaticAssert(Dimension >= 3);
 160         data[0] = x;
 161         data[1] = y;
 162         data[2] = z;
 163 }
 164
 165 template<typename T, int Dimension>
 166 Vector<T, Dimension>::Vector(const TypeReference x, const TypeReference y, const TypeReference z, const TypeReference w)
 167 {
 168         EffectsStaticAssert(Dimension >= 4);
 169         data[0] = x;
 170         data[1] = y;
 171         data[2] = z;
 172         data[3] = w;
 173 }
 174
 175 template<typename T, int Dimension>
 176 Vector<T, Dimension>::Vector(const VectorType& other)
 177 {
 178         for (int i = 0; i < Dimension; i++)
 179         {
 180                 data[i] = other.data[i];
 181         }
 182 }
 183
 184 template<typename T, int Dimension>
 185 Vector<T, Dimension>& Vector<T, Dimension>::operator=(const VectorType& rhv)
 186 {
 187         if (this != &rhv)
 188         {
 189                 for (int i = 0; i < Dimension; i++)
 190                 {
 191                         data[i] = rhv.data[i];
 192                 }
 193         }
 194         return *this;
 195 }
 196
 197 template<typename T, int Dimension>
 198 typename Vector<T, Dimension>::VectorType& Vector<T, Dimension>::Set(const VectorType& other)
 199 {
 200         for (int i = 0; i < Dimension; i++)
 201         {
 202                 data[i] = other.data[i];
 203         }
 204         return *this;
 205 }
 206
 207 template<typename T, int Dimension>
 208 typename Vector<T, Dimension>::VectorType& Vector<T, Dimension>::Set(const TypeReference value)
 209 {
 210         for (int i = 0; i < Dimension; i++)
 211         {
 212                 data[i] = value;
 213         }
 214         return *this;
 215 }
 216
 217 template<typename T, int Dimension>
 218 typename Vector<T, Dimension>::VectorType& Vector<T, Dimension>::FillFromArray(const T* value)
 219 {
 220         for (int i = 0; i < Dimension; i++)
 221         {
 222                 data[i] = value[i];
 223         }
 224         return *this;
 225 }
 226
 227 template<typename T, int Dimension>
 228 typename Vector<T, Dimension>::VectorType Vector<T, Dimension>::MakeFromArray(const T* value)
 229 {
 230         VectorType result;
 231         result.FillFromArray(value);
 232         return result;
 233 }
 234
 235
 236 template<typename T, int Dimension>
 237 Vector<T, Dimension> Vector<T, Dimension>::operator - (void) const
 238 {
 239         return GetInversed();
 240 }
 241
 242 template<typename T, int Dimension>
 243 Vector<T, Dimension>& Vector<T, Dimension>::Inverse(void)
 244 {
 245         for (int i = 0; i < Dimension; i++)
 246         {
 247                 data[i] = -data[i];
 248         }
 249         return *this;
 250 }
 251
 252 template<typename T, int Dimension>
 253 Vector<T, Dimension> Vector<T, Dimension>::GetInversed(void) const
 254 {
 255         VectorType result;
 256         for (int i = 0; i < Dimension; i++)
 257         {
 258                 result.data[i] = -data[i];
 259         }
 260         return result;
 261 }
 262
 263 template<typename T, int Dimension>
 264 Vector<T, Dimension>& Vector<T, Dimension>::operator += (const Vector<T, Dimension>& rhv)
 265 {
 266         for (int i = 0; i < Dimension; i++)
 267         {
 268                 data[i] += rhv.data[i];
 269         }
 270         return *this;
 271 }
 272
 273 template<typename T, int Dimension>
 274 Vector<T, Dimension>& Vector<T, Dimension>::operator += (const TypeReference rhv)
 275 {
 276         for (int i = 0; i < Dimension; i++)
 277         {
 278                 data[i] += rhv;
 279         }
 280         return *this;
 281 }
 282
 283 template<typename T, int Dimension>
 284 Vector<T, Dimension>& Vector<T, Dimension>::operator -= (const VectorType& rhv)
 285 {
 286         for (int i = 0; i < Dimension; i++)
 287         {
 288                 data[i] -= rhv.data[i];
 289         }
 290         return *this;
 291 }
 292
 293 template<typename T, int Dimension>
 294 Vector<T, Dimension>& Vector<T, Dimension>::operator -= (const TypeReference rhv)
 295 {
 296         for (int i = 0; i < Dimension; i++)
 297                 data[i] -= rhv;
 298         return *this;
 299 }
 300
 301 template<typename T, int Dimension>
 302 Vector<T, Dimension>& Vector<T, Dimension>::operator *= (const VectorType& rhv)
 303 {
 304         for (int i = 0; i < Dimension; i++)
 305         {
 306                 data[i] *= rhv.data[i];
 307         }
 308         return *this;
 309 }
 310
 311 template<typename T, int Dimension>
 312 Vector<T, Dimension>& Vector<T, Dimension>::operator *= (const TypeReference rhv)
 313 {
 314         for (int i = 0; i < Dimension; i++)
 315         {
 316                 data[i] *= rhv;
 317         }
 318         return *this;
 319 }
 320
 321 template<typename T, int Dimension>
 322 Vector<T, Dimension>& Vector<T, Dimension>::operator /= (const VectorType& rhv)
 323 {
 324         for (int i = 0; i < Dimension; i++)
 325         {
 326                 data[i] /= rhv.data[i];
 327         }
 328         return *this;
 329 }
 330
 331 template<typename T, int Dimension>
 332 Vector<T, Dimension>& Vector<T, Dimension>::operator /= (const TypeReference rhv)
 333 {
 334         for (int i = 0; i < Dimension; i++)
 335         {
 336                 data[i] /= rhv;
 337         }
 338         return *this;
 339 }
 340
 341 template<typename T, int Dimension>
 342 T* Vector<T, Dimension>::GetPointer(void)
 343 {
 344         return &(data[0]);
 345 }
 346
 347 template<typename T, int Dimension>
 348 const T* Vector<T, Dimension>::GetPointer(void) const
 349 {
 350         return &(data[0]);
 351 }
 352
 353 template<typename T, int Dimension>
 354 Vector<T, Dimension>& Vector<T, Dimension>::Normalize(void)
 355 {
 356         const static T t0(0.0f);
 357
 358         const TypeReference dist = Length();
 359         if (EffectsEqual(t0, dist))
 360         {
 361                 return *this;
 362         }
 363
 364         return operator /= (dist);
 365 }
 366
 367 template<typename T, int Dimension>
 368 Vector<T, Dimension> Vector<T, Dimension>::GetNormalized(void) const
 369 {
 370         const static T t0(0.0f);
 371
 372         const T dist = Length();
 373         if (EffectsEqual(t0, dist))
 374         {
 375                 return *this;
 376         }
 377
 378         return *this / dist;
 379 }
 380
 381 template<typename T, int Dimension>
 382 Vector<T, Dimension>& Vector<T, Dimension>::Lerp(const VectorType& to, const TypeReference coeff)
 383 {
 384         for (int i = 0; i < Dimension; i++)
 385         {
 386                 data[i] += (to.data[i] - data[i]) * coeff;
 387         }
 388         return *this;
 389 }
 390
 391 template<typename T, int Dimension>
 392 Vector<T, Dimension> Vector<T, Dimension>::GetLerped(const VectorType& to, const TypeReference coeff) const
 393 {
 394         VectorType result(*this);
 395         return result.Lerp(to, coeff);
 396 }
 397
 398 template<typename T, int Dimension>
 399 Vector<T, Dimension>& Vector<T, Dimension>::MakeLerped(const VectorType& from, const VectorType& to, const TypeReference coeff)
 400 {
 401         *this = from;
 402         return Lerp(to, coeff);
 403 }
 404
 405 template<typename T, int Dimension>
 406 Vector<T, Dimension> Vector<T, Dimension>::CreateLerped(const VectorType& from, const VectorType& to, const TypeReference coeff)
 407 {
 408         return VectorType().MakeLerped(from, to, coeff);
 409 }
 410
 411 template<typename T, int Dimension>
 412 T Vector<T, Dimension>::Dot(const VectorType& other) const
 413 {
 414         T result = T();
 415         for (int i = 0; i < Dimension; i++)
 416         {
 417                 result += data[i] * other.data[i];
 418         }
 419         return result;
 420 }
 421
 422 template<typename T, int Dimension>
 423 T Vector<T, Dimension>::LengthSqr(void) const
 424 {
 425         T result = T();
 426         for (int i = 0; i < Dimension; i++)
 427         {
 428                 result += data[i] * data[i];
 429         }
 430         return result;
 431 }
 432
 433 template<typename T, int Dimension>
 434 T Vector<T, Dimension>::Length(void) const
 435 {
 436         return EffectsSqrt(LengthSqr());
 437 }
 438
 439 template<typename T, int Dimension>
 440 T Vector<T, Dimension>::DistanceSqr(const VectorType& other) const
 441 {
 442         T result = T();
 443         for (int i = 0; i < Dimension; i++)
 444         {
 445                 T t = data[i] - other.data[i];
 446                 result += t * t;
 447         }
 448         return result;
 449 }
 450
 451 template<typename T, int Dimension>
 452 T Vector<T, Dimension>::Distance(const VectorType& other) const
 453 {
 454         return effects_sqrt(DistanceSqr(other));
 455 }
 456
 457 template<typename T, int Dimension>
 458 Vector<T, 2> Vector<T, Dimension>::Swizzle(unsigned int x, unsigned int y) const
 459 {
 460         return Vector<T, 2>(data[x], data[y]);
 461 }
 462
 463 template<typename T, int Dimension>
 464 Vector<T, 3> Vector<T, Dimension>::Swizzle(unsigned int x, unsigned int y, unsigned int z) const
 465 {
 466         return Vector<T, 3>(data[x], data[y], data[z]);
 467 }
 468
 469 template<typename T, int Dimension>
 470 Vector<T, 4> Vector<T, Dimension>::Swizzle(unsigned int x, unsigned int y, unsigned int z, unsigned int w) const
 471 {
 472         return Vector<T, 4>(data[x], data[y], data[z], data[w]);
 473 }
 474
 475 template<typename T, int Dimension>
 476 bool Vector<T, Dimension>::IsEqual(const Vector<T, Dimension>& rhv, const TypeReference epsilon) const
 477 {
 478         for (int i = 0; i < Dimension; i++)
 479         {
 480                 if (!EffectsEqual(data[i], rhv.data[i], epsilon))
 481                 {
 482                         return false;
 483                 }
 484         }
 485
 486         return true;
 487 }
 488
 489 template<typename T, int Dimension>
 490 bool IsEqual(const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv, const typename Vector<T, Dimension>::TypeReference epsilon)
 491 {
 492         return lhv.IsEqual(rhv, epsilon);
 493 }
 494
 495 template<typename T, int Dimension>
 496 Vector<T, Dimension> operator + (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 497 {
 498         Vector<T, Dimension> result;
 499         for (int i = 0; i < Dimension; i++)
 500         {
 501                 result.data[i] = lhv.data[i] + rhv.data[i];
 502         }
 503         return result;
 504 }
 505
 506 template<typename T, int Dimension>
 507 Vector<T, Dimension> operator + (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 508 {
 509         Vector<T, Dimension> result;
 510         for (int i = 0; i < Dimension; i++)
 511         {
 512                 result.data[i] = lhv.data[i] + rhv;
 513         }
 514         return result;
 515 }
 516
 517 template<typename T, int Dimension>
 518 Vector<T, Dimension> operator + (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 519 {
 520         Vector<T, Dimension> result;
 521         for (int i = 0; i < Dimension; i++)
 522         {
 523                 result.data[i] = lhv + rhv.data[i];
 524         }
 525         return result;
 526 }
 527
 528 template<typename T, int Dimension>
 529 Vector<T, Dimension> operator - (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 530 {
 531         Vector<T, Dimension> result;
 532         for (int i = 0; i < Dimension; i++)
 533         {
 534                 result.data[i] = lhv.data[i] - rhv.data[i];
 535         }
 536         return result;
 537 }
 538
 539 template<typename T, int Dimension>
 540 Vector<T, Dimension> operator - (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 541 {
 542         Vector<T, Dimension> result;
 543         for (int i = 0; i < Dimension; i++)
 544         {
 545                 result.data[i] = lhv.data[i] - rhv;
 546         }
 547         return result;
 548 }
 549
 550 template<typename T, int Dimension>
 551 Vector<T, Dimension> operator - (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 552 {
 553         Vector<T, Dimension> result;
 554         for (int i = 0; i < Dimension; i++)
 555         {
 556                 result.data[i] = lhv - rhv.data[i];
 557         }
 558         return result;
 559 }
 560
 561 template<typename T, int Dimension>
 562 Vector<T, Dimension> operator * (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 563 {
 564         Vector<T, Dimension> result;
 565         for (int i = 0; i < Dimension; i++)
 566         {
 567                 result.data[i] = lhv.data[i] * rhv.data[i];
 568         }
 569         return result;
 570 }
 571
 572 template<typename T, int Dimension>
 573 Vector<T, Dimension> operator * (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 574 {
 575         Vector<T, Dimension> result;
 576         for (int i = 0; i < Dimension; i++)
 577         {
 578                 result.data[i] = lhv.data[i] * rhv;
 579         }
 580         return result;
 581 }
 582
 583 template<typename T, int Dimension>
 584 Vector<T, Dimension> operator * (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 585 {
 586         Vector<T, Dimension> result;
 587         for (int i = 0; i < Dimension; i++)
 588         {
 589                 result.data[i] = lhv * rhv.data[i];
 590         }
 591         return result;
 592 }
 593
 594 template<typename T, int Dimension>
 595 Vector<T, Dimension> operator / (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 596 {
 597         Vector<T, Dimension> result;
 598         for (int i = 0; i < Dimension; i++)
 599         {
 600                 result.data[i] = lhv.data[i] / rhv.data[i];
 601         }
 602         return result;
 603 }
 604
 605 template<typename T, int Dimension>
 606 Vector<T, Dimension> operator / (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 607 {
 608         Vector<T, Dimension> result;
 609         for (int i = 0; i < Dimension; i++)
 610         {
 611                 result.data[i] = lhv.data[i] / rhv;
 612         }
 613         return result;
 614 }
 615
 616 template<typename T, int Dimension>
 617 inline Vector<T, Dimension> operator / (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 618 {
 619         Vector<T, Dimension> result;
 620         for (int i = 0; i < Dimension; i++)
 621         {
 622                 result.data[i] = lhv / rhv.data[i];
 623         }
 624         return result;
 625 }
 626
 627 template<typename T, int Dimension>
 628 bool operator == (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 629 {
 630         for (int i = 0; i < Dimension; i++)
 631         {
 632                 if (!EffectsEqual(lhv.data[i], rhv.data[i]))
 633                 {
 634                         return false;
 635                 }
 636         }
 637         return true;
 638 }
 639
 640 template<typename T, int Dimension>
 641 bool operator == (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 642 {
 643         for (int i = 0; i < Dimension; i++)
 644         {
 645                 if (!EffectsEqual(lhv.data[i], rhv))
 646                 {
 647                         return false;
 648                 }
 649         }
 650         return true;
 651 }
 652
 653 template<typename T, int Dimension>
 654 bool operator == (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 655 {
 656         for (int i = 0; i < Dimension; i++)
 657         {
 658                 if (!EffectsEqual(lhv, rhv.data[i]))
 659                 {
 660                         return false;
 661                 }
 662         }
 663         return true;
 664 }
 665
 666 template<typename T, int Dimension>
 667 inline bool operator != (const Vector<T, Dimension>& lhv, const Vector<T, Dimension>& rhv)
 668 {
 669         return !(lhv == rhv);
 670 }
 671
 672 template<typename T, int Dimension>
 673 bool operator != (const Vector<T, Dimension>& lhv, const typename Vector<T, Dimension>::TypeReference rhv)
 674 {
 675         return !(lhv == rhv);
 676 }
 677
 678 template<typename T, int Dimension>
 679 bool operator != (const typename Vector<T, Dimension>::TypeReference lhv, const Vector<T, Dimension>& rhv)
 680 {
 681         return !(lhv == rhv);
 682 }
 683
 684 }}}}} //Tizen::Ui::Effects::_Renderer::Math
 685
 686 #endif //_FUI_EFFECTS_INTERNAL_RENDERER_MATH_VECTOR_H_