dali/public-api/math/vector4.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 // CLASS HEADER
  18 #include <dali/public-api/math/vector4.h>
  19
  20 // EXTERNAL INCLUDES
  21 #include <math.h>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali/public-api/common/dali-common.h>
  25 #include <dali/public-api/math/vector2.h>
  26 #include <dali/public-api/math/vector3.h>
  27 #include <dali/public-api/math/math-utils.h>
  28 #include <dali/internal/render/common/performance-monitor.h>
  29
  30 namespace Dali
  31 {
  32
  33 using Internal::PerformanceMonitor;
  34
  35 const Vector4 Vector4::ONE(1.0f, 1.0f, 1.0f, 1.0f);
  36 const Vector4 Vector4::XAXIS(1.0f, 0.0f, 0.0f, 0.0f);
  37 const Vector4 Vector4::YAXIS(0.0f, 1.0f, 0.0f, 0.0f);
  38 const Vector4 Vector4::ZAXIS(0.0f, 0.0f, 1.0f, 0.0f);
  39 const Vector4 Vector4::ZERO(0.0f, 0.0f, 0.0f, 0.0f);
  40
  41 Vector4::Vector4( const Vector2& vec2 )
  42 : x(vec2.x),
  43   y(vec2.y),
  44   z(0.0f),
  45   w(0.0f)
  46 {
  47 }
  48
  49 Vector4::Vector4( const Vector3& vec3 )
  50 : x(vec3.x),
  51   y(vec3.y),
  52   z(vec3.z),
  53   w(0.0f)
  54 {
  55 }
  56
  57 Vector4& Vector4::operator=(const Vector2& vec2 )
  58 {
  59   // only set x and y
  60   x = vec2.x;
  61   y = vec2.y;
  62   return *this;
  63 }
  64
  65 Vector4& Vector4::operator=(const Vector3& vec3 )
  66 {
  67   // only set x, y and z
  68   x = vec3.x;
  69   y = vec3.y;
  70   z = vec3.z;
  71   return *this;
  72 }
  73
  74
  75 bool Vector4::operator==(const Vector4& rhs) const
  76 {
  77   if (fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x) )
  78   {
  79     return false;
  80   }
  81   if (fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y) )
  82   {
  83     return false;
  84   }
  85   if (fabsf(z - rhs.z) > GetRangedEpsilon(z, rhs.z) )
  86   {
  87     return false;
  88   }
  89   if (fabsf(w - rhs.w) > GetRangedEpsilon(w, rhs.w) )
  90   {
  91     return false;
  92   }
  93
  94   return true;
  95 }
  96
  97 float Vector4::Dot(const Vector3 &other) const
  98 {
  99   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
 100
 101   return x * other.x + y * other.y + z * other.z;
 102 }
 103
 104 float Vector4::Dot(const Vector4 &other) const
 105 {
 106   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
 107
 108   return x * other.x + y * other.y + z * other.z;
 109 }
 110
 111 float Vector4::Dot4(const Vector4 &other) const
 112 {
 113   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
 114
 115   return x * other.x + y * other.y + z * other.z + w * other.w;
 116 }
 117
 118 Vector4 Vector4::Cross(const Vector4 &other) const
 119 {
 120   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,6);
 121
 122   return Vector4( (y * other.z) - (z * other.y),
 123                   (z * other.x) - (x * other.z),
 124                   (x * other.y) - (y * other.x),
 125                   0.0f);
 126 }
 127
 128 // Will always return positive square root
 129 float Vector4::Length() const
 130 {
 131   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
 132
 133   return sqrtf(x*x + y*y + z*z);
 134 }
 135
 136 float Vector4::LengthSquared() const
 137 {
 138   MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
 139
 140   return x*x + y*y + z*z;
 141 }
 142
 143 void Vector4::Normalize()
 144 {
 145   const float length = Length();
 146
 147   // In the case where the length is exactly zero, the vector cannot be normalized.
 148   if ( ! EqualsZero( length ) )
 149   {
 150     MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
 151
 152     const float inverseLength = 1.0f / length;
 153     x *= inverseLength;
 154     y *= inverseLength;
 155     z *= inverseLength;
 156   }
 157 }
 158
 159 void Vector4::Clamp( const Vector4& min, const Vector4& max )
 160 {
 161   Dali::ClampInPlace<float>( x, min.x, max.x );
 162   Dali::ClampInPlace<float>( y, min.y, max.y );
 163   Dali::ClampInPlace<float>( z, min.z, max.z );
 164   Dali::ClampInPlace<float>( w, min.w, max.w );
 165 }
 166
 167 std::ostream& operator<< (std::ostream& o, const Vector4& vector)
 168 {
 169   return o << "[" << vector.x << ", " << vector.y << ", " << vector.z << ", " << vector.w << "]";
 170 }
 171
 172 Vector4 Clamp( const Vector4& v, const float& min, const float& max )
 173 {
 174   Vector4 result( v );
 175   result.Clamp( Vector4( min, min, min, min ), Vector4( max, max, max, max) );
 176
 177   return result;
 178 }
 179
 180 } // namespace Dali