framework/common/tcuVectorUtil.hpp

   1 #ifndef _TCUVECTORUTIL_HPP
   2 #define _TCUVECTORUTIL_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Tester Core
   5  * ----------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Vector utility functions.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "tcuVector.hpp"
  28 #include "deMeta.hpp"
  29 #include "deMath.h"
  30 #include "deInt32.h"
  31
  32 #include <ostream>
  33 #include <math.h>
  34
  35 namespace tcu
  36 {
  37
  38 static const float PI = 3.141592653589793238f;
  39
  40 #if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX) || (DE_OS == DE_OS_QNX) || (DE_OS == DE_OS_WIN32 && DE_COMPILER == DE_COMPILER_CLANG)
  41 inline float abs                        (float f) { return deFloatAbs(f); }
  42 #endif
  43
  44 template<typename T> inline T add                       (T a, T b) { return a + b; }
  45 template<typename T> inline T sub                       (T a, T b) { return a - b; }
  46 template<typename T> inline T mul                       (T a, T b) { return a * b; }
  47 template<typename T> inline T div                       (T a, T b) { return a / b; }
  48
  49 template<typename T> inline T bitwiseNot        (T a)           { return ~a; }
  50 template<typename T> inline T bitwiseAnd        (T a, T b)      { return a & b; }
  51 template<typename T> inline T bitwiseOr         (T a, T b)      { return a | b; }
  52 template<typename T> inline T bitwiseXor        (T a, T b)      { return a ^ b; }
  53
  54 template<typename T> inline T logicalNot        (T a)           { return !a; }
  55 template<typename T> inline T logicalAnd        (T a, T b)      { return a && b; }
  56 template<typename T> inline T logicalOr         (T a, T b)      { return a || b; }
  57
  58 template<typename T>    inline T                mod             (T a, T b)                      { return a % b; }
  59 template<>                              inline float    mod             (float x, float y)      { return x - y * deFloatFloor(x / y); }
  60
  61 template<typename T>    inline  T                       negate                          (T f)                   { return -f; }
  62 template<>                              inline  deUint32        negate<deUint32>        (deUint32 f)    { return (deUint32)-(int)f;     }
  63
  64 inline float radians            (float f) { return deFloatRadians(f); }
  65 inline float degrees            (float f) { return deFloatDegrees(f); }
  66 inline float inverseSqrt        (float f) { return deFloatRsq(f); }
  67 inline float sign                       (float f) { return (f < 0.0f) ? -1.0f : ((f > 0.0f) ? +1.0f : 0.0f); }
  68 inline float fract                      (float f) { return f - deFloatFloor(f); }
  69 inline float mix                        (float x, float y, float a) { return x * (1.0f - a) + y * a; }
  70 inline float step                       (float edge, float x) { return (x < edge) ? 0.0f : 1.0f; }
  71 inline float smoothStep         (float edge0, float edge1, float x)
  72 {
  73         if (x <= edge0) return 0.0f;
  74         if (x >= edge1) return 1.0f;
  75         float t = de::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
  76         return t * t * (3.0f - 2.0f * t);
  77 }
  78
  79 inline double mix                       (double x, double y, double a) { return x * (1.0 - a) + y * a; }
  80 inline double step                      (double edge, double x) { return (x < edge) ? 0.0 : 1.0; }
  81
  82 inline float length                     (float f) { return deFloatAbs(f); }
  83 inline float distance           (float x, float y) { return deFloatAbs(x - y); }
  84 inline float dot                        (float x, float y) { return (x * y); }
  85
  86 inline float normalize          (float f) { return sign(f); }
  87 inline float faceForward        (float n, float i, float ref) { return ((ref * i) < 0.0f) ? n : -n; }
  88 inline float reflect            (float i, float n) { return i - 2.0f * (n * i) * n; }
  89 inline float refract            (float i, float n, float eta)
  90 {
  91         float cosAngle = (n * i);
  92         float k = 1.0f - eta * eta * (1.0f - cosAngle * cosAngle);
  93         if (k < 0.0f)
  94                 return 0.0f;
  95         else
  96                 return eta * i - (eta * cosAngle + deFloatSqrt(k)) * n;
  97 }
  98
  99 template<typename T> inline bool        lessThan                        (T a, T b) { return (a < b); }
 100 template<typename T> inline bool        lessThanEqual           (T a, T b) { return (a <= b); }
 101 template<typename T> inline bool        greaterThan                     (T a, T b) { return (a > b); }
 102 template<typename T> inline bool        greaterThanEqual        (T a, T b) { return (a >= b); }
 103 template<typename T> inline bool        equal                           (T a, T b) { return (a == b); }
 104 template<typename T> inline bool        notEqual                        (T a, T b) { return (a != b); }
 105 template<typename T> inline bool        allEqual                        (T a, T b) { return (a == b); }
 106 template<typename T> inline bool        anyNotEqual                     (T a, T b) { return (a != b); }
 107
 108 inline bool boolNot                             (bool a) { return !a; }
 109
 110 inline int chopToInt                    (float a) { return deChopFloatToInt32(a); }
 111
 112 inline float roundToEven (float a)
 113 {
 114         float q = deFloatFrac(a);
 115         float r = a-q;
 116
 117         if (q > 0.5f)
 118                 r += 1.0f;
 119         else if (q == 0.5 && (((int)r) % 2 != 0))
 120                 r += 1.0f;
 121
 122         return r;
 123 }
 124
 125 template <typename T, int Size>
 126 inline T dot (const Vector<T, Size>& a, const Vector<T, Size>& b)
 127 {
 128         T res = T();
 129         for (int i = 0; i < Size; i++)
 130                 res += a.m_data[i] * b.m_data[i];
 131         return res;
 132 }
 133
 134 template <typename T, int Size>
 135 inline T lengthSquared (const Vector<T, Size>& a)
 136 {
 137         T sqSum = T();
 138         for (int i = 0; i < Size; i++)
 139                 sqSum += a.m_data[i] * a.m_data[i];
 140         return sqSum;
 141 }
 142
 143 template <typename T, int Size>
 144 inline typename de::meta::EnableIf<T, de::meta::TypesSame<T, double>::Value>::Type length (const Vector<T, Size>& a)
 145 {
 146         return ::sqrt(lengthSquared(a));
 147 }
 148
 149 template <typename T, int Size>
 150 inline typename de::meta::EnableIf<T, de::meta::TypesSame<T, float>::Value>::Type length (const Vector<T, Size>& a)
 151 {
 152         return deFloatSqrt(lengthSquared(a));
 153 }
 154
 155 template <typename T, int Size>
 156 inline T distance (const Vector<T, Size>& a, const Vector<T, Size>& b)
 157 {
 158         return length(a - b);
 159 }
 160
 161 template <typename T, int Size>
 162 inline Vector<T, Size> cross (const Vector<T, Size>& a, const Vector<T, Size>& b)
 163 {
 164         DE_STATIC_ASSERT(Size == 3);
 165         return Vector<T, Size>(
 166                 a.y() * b.z() - b.y() * a.z(),
 167                 a.z() * b.x() - b.z() * a.x(),
 168                 a.x() * b.y() - b.x() * a.y());
 169 }
 170
 171 template <typename T, int Size>
 172 inline Vector<T, Size> normalize (const Vector<T, Size>& a)
 173 {
 174         T ooLen = T(1) / length(a);
 175         Vector<T, Size> res;
 176         for (int i = 0; i < Size; i++)
 177                 res.m_data[i] = ooLen * a.m_data[i];
 178         return res;
 179 }
 180
 181 template <typename T, int Size>
 182 inline Vector<T, Size> faceForward (const Vector<T, Size>& n, const Vector<T, Size>& i, const Vector<T, Size>& ref)
 183 {
 184         return (dot(ref, i) < T(0)) ? n: -n;
 185 }
 186
 187 template <typename T, int Size>
 188 inline Vector<T, Size> reflect (const Vector<T, Size>& i, const Vector<T, Size>& n)
 189 {
 190         return i - T(2) * dot(n, i) * n;
 191 }
 192
 193 template <typename T, int Size>
 194 inline Vector<T, Size> refract (const Vector<T, Size>& i, const Vector<T, Size>& n, T eta)
 195 {
 196         T cosAngle = dot(n, i);
 197         T k = T(1) - eta * eta * (T(1) - cosAngle * cosAngle);
 198         if (k < T(0))
 199                 return Vector<T, Size>(T(0));
 200         else
 201                 return i * eta - n * T(eta * cosAngle + ::sqrt(k));
 202 }
 203
 204 template <int Size>
 205 Vector<float, Size> mix (const Vector<float, Size>& x, const Vector<float, Size>& y, float a)
 206 {
 207         Vector<float, Size> res;
 208         for (int i = 0; i < Size; i++)
 209                 res.m_data[i] = deFloatMix(x.m_data[i], y.m_data[i], a);
 210         return res;
 211 }
 212
 213 template <int Size>
 214 Vector<double, Size> mix (const Vector<double, Size>& x, const Vector<double, Size>& y, double a)
 215 {
 216         Vector<double, Size> res;
 217         for (int i = 0; i < Size; i++)
 218                 res.m_data[i] = deMix(x.m_data[i], y.m_data[i], a);
 219         return res;
 220 }
 221
 222 // Piece-wise compare operators.
 223
 224 template <typename T, int Size>
 225 inline Vector<bool, Size> equal (const Vector<T, Size>& a, const Vector<T, Size>& b)
 226 {
 227         Vector<bool, Size> res;
 228         for (int i = 0; i < Size; i++)
 229                 res.m_data[i] = a.m_data[i] == b.m_data[i];
 230         return res;
 231 }
 232
 233 template <typename T, int Size>
 234 inline Vector<bool, Size> notEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
 235 {
 236         Vector<bool, Size> res;
 237         for (int i = 0; i < Size; i++)
 238                 res.m_data[i] = a.m_data[i] != b.m_data[i];
 239         return res;
 240 }
 241
 242 template <typename T, int Size>
 243 inline Vector<bool, Size> lessThan (const Vector<T, Size>& a, const Vector<T, Size>& b)
 244 {
 245         Vector<bool, Size> res;
 246         for (int i = 0; i < Size; i++)
 247                 res.m_data[i] = a.m_data[i] < b.m_data[i];
 248         return res;
 249 }
 250
 251 template <typename T, int Size>
 252 inline Vector<bool, Size> lessThanEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
 253 {
 254         Vector<bool, Size> res;
 255         for (int i = 0; i < Size; i++)
 256                 res.m_data[i] = a.m_data[i] <= b.m_data[i];
 257         return res;
 258 }
 259
 260 template <typename T, int Size>
 261 inline Vector<bool, Size> greaterThan (const Vector<T, Size>& a, const Vector<T, Size>& b)
 262 {
 263         Vector<bool, Size> res;
 264         for (int i = 0; i < Size; i++)
 265                 res.m_data[i] = a.m_data[i] > b.m_data[i];
 266         return res;
 267 }
 268
 269 template <typename T, int Size>
 270 inline Vector<bool, Size> greaterThanEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
 271 {
 272         Vector<bool, Size> res;
 273         for (int i = 0; i < Size; i++)
 274                 res.m_data[i] = a.m_data[i] >= b.m_data[i];
 275         return res;
 276 }
 277
 278 // Equality comparison operators.
 279
 280 template <typename T, int Size>
 281 inline bool allEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
 282 {
 283         bool res = true;
 284         for (int i = 0; i < Size; i++)
 285                 res = res && a.m_data[i] == b.m_data[i];
 286         return res;
 287 }
 288
 289 template <typename T, int Size>
 290 inline bool anyNotEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
 291 {
 292         bool res = false;
 293         for (int i = 0; i < Size; i++)
 294                 res = res || a.m_data[i] != b.m_data[i];
 295         return res;
 296 }
 297
 298 // Boolean built-ins.
 299
 300 template <int Size>
 301 inline Vector<bool, Size> boolNot (const Vector<bool, Size>& a)
 302 {
 303         Vector<bool, Size> res;
 304         for (int i = 0; i < Size; i++)
 305                 res.m_data[i] = !a.m_data[i];
 306         return res;
 307 }
 308
 309 template <int Size>
 310 inline bool boolAny (const Vector<bool, Size>& a)
 311 {
 312         for (int i = 0; i < Size; i++)
 313                 if (a.m_data[i] == true)
 314                         return true;
 315         return false;
 316 }
 317
 318 template <int Size>
 319 inline bool boolAll (const Vector<bool, Size>& a)
 320 {
 321         for (int i = 0; i < Size; i++)
 322                 if (a.m_data[i] == false)
 323                         return false;
 324         return true;
 325 }
 326
 327 template <int Size>
 328 Vector<int, Size> chopToInt (const Vector<float, Size>& v)
 329 {
 330         Vector<int, Size> res;
 331         for (int i = 0; i < Size; i++)
 332                 res.m_data[i] = chopToInt(v.m_data[i]);
 333         return res;
 334 }
 335
 336 // Vector construction using selection based on boolean vector.
 337
 338 template <typename T, int Size>
 339 inline Vector<T, Size> select (T trueVal, T falseVal, const Vector<bool, Size>& cond)
 340 {
 341         Vector<T, Size> res;
 342         for (int i = 0; i < Size; i++)
 343                 res[i] = cond[i] ? trueVal : falseVal;
 344         return res;
 345 }
 346
 347 // Component-wise selection.
 348
 349 template <typename T, int Size>
 350 inline Vector<T, Size> select (const Vector<T, Size>& trueVal, const Vector<T, Size>& falseVal, const Vector<bool, Size>& cond)
 351 {
 352         Vector<T, Size> res;
 353         for (int i = 0; i < Size; i++)
 354                 res[i] = cond[i] ? trueVal[i] : falseVal[i];
 355         return res;
 356 }
 357
 358 // Absolute difference (abs(a - b))
 359
 360 template<typename T, int Size>
 361 static inline Vector<T, Size> absDiff (const Vector<T, Size>& a, const Vector<T, Size>& b)
 362 {
 363         Vector<T, Size> res;
 364
 365         for (int ndx = 0; ndx < Size; ndx++)
 366                 res[ndx] = (a[ndx] > b[ndx]) ? (a[ndx] - b[ndx]) : (b[ndx] - a[ndx]);
 367
 368         return res;
 369 }
 370
 371 // Macros for component-wise ops.
 372
 373 #define TCU_DECLARE_VECTOR_UNARY_FUNC(FUNC_NAME, OP_NAME)       \
 374 template <typename T, int Size>                                                         \
 375 Vector<T, Size> FUNC_NAME (const Vector<T, Size>& v)            \
 376 {                                                                                                                       \
 377         Vector<T, Size> res;                                                                    \
 378         for (int i = 0; i < Size; i++)                                                  \
 379                 res.m_data[i] = OP_NAME(v.m_data[i]);                           \
 380         return res;                                                                                             \
 381 }
 382
 383 #define TCU_DECLARE_VECTOR_BINARY_FUNC(FUNC_NAME, OP_NAME)                                              \
 384 template <typename T, int Size>                                                                                                 \
 385 Vector<T, Size> FUNC_NAME (const Vector<T, Size>& a, const Vector<T, Size>& b)  \
 386 {                                                                                                                                                               \
 387         Vector<T, Size> res;                                                                                                            \
 388         for (int i = 0; i < Size; i++)                                                                                          \
 389                 res.m_data[i] = OP_NAME(a.m_data[i], b.m_data[i]);                                              \
 390         return res;                                                                                                                                     \
 391 }
 392
 393 #define TCU_DECLARE_VECTOR_TERNARY_FUNC(FUNC_NAME, OP_NAME)                                                                                                     \
 394 template <typename T, int Size>                                                                                                                                                         \
 395 Vector<T, Size> FUNC_NAME (const Vector<T, Size>& a, const Vector<T, Size>& b, const Vector<T, Size>& c)        \
 396 {                                                                                                                                                                                                                       \
 397         Vector<T, Size> res;                                                                                                                                                                    \
 398         for (int i = 0; i < Size; i++)                                                                                                                                                  \
 399                 res.m_data[i] = OP_NAME(a.m_data[i], b.m_data[i], c.m_data[i]);                                                                         \
 400         return res;                                                                                                                                                                                             \
 401 }
 402
 403 // \todo [2011-07-01 pyry] Add some prefix to vector funcs and remove this hack.
 404 #if defined(min)
 405 #       undef min
 406 #endif
 407 #if defined(max)
 408 #       undef max
 409 #endif
 410
 411 TCU_DECLARE_VECTOR_UNARY_FUNC(negate, negate)
 412 TCU_DECLARE_VECTOR_UNARY_FUNC(bitwiseNot, bitwiseNot)
 413 TCU_DECLARE_VECTOR_BINARY_FUNC(add, add)
 414 TCU_DECLARE_VECTOR_BINARY_FUNC(sub, sub)
 415 TCU_DECLARE_VECTOR_BINARY_FUNC(mul, mul)
 416 TCU_DECLARE_VECTOR_BINARY_FUNC(div, div)
 417 TCU_DECLARE_VECTOR_BINARY_FUNC(mod, mod)
 418 TCU_DECLARE_VECTOR_BINARY_FUNC(bitwiseAnd, bitwiseAnd)
 419 TCU_DECLARE_VECTOR_BINARY_FUNC(bitwiseOr, bitwiseOr)
 420 TCU_DECLARE_VECTOR_BINARY_FUNC(bitwiseXor, bitwiseXor)
 421 TCU_DECLARE_VECTOR_UNARY_FUNC(logicalNot, logicalNot)
 422 TCU_DECLARE_VECTOR_BINARY_FUNC(logicalAnd, logicalAnd)
 423 TCU_DECLARE_VECTOR_BINARY_FUNC(logicalOr, logicalOr)
 424
 425 TCU_DECLARE_VECTOR_UNARY_FUNC(radians, deFloatRadians)
 426 TCU_DECLARE_VECTOR_UNARY_FUNC(degrees, deFloatDegrees)
 427 TCU_DECLARE_VECTOR_UNARY_FUNC(sin, deFloatSin)
 428 TCU_DECLARE_VECTOR_UNARY_FUNC(cos, deFloatCos)
 429 TCU_DECLARE_VECTOR_UNARY_FUNC(tan, deFloatTan)
 430 TCU_DECLARE_VECTOR_UNARY_FUNC(asin, deFloatAsin)
 431 TCU_DECLARE_VECTOR_UNARY_FUNC(acos, deFloatAcos)
 432 TCU_DECLARE_VECTOR_UNARY_FUNC(atan, deFloatAtanOver)
 433 TCU_DECLARE_VECTOR_BINARY_FUNC(atan2, deFloatAtan2)
 434 TCU_DECLARE_VECTOR_UNARY_FUNC(sinh, deFloatSinh)
 435 TCU_DECLARE_VECTOR_UNARY_FUNC(cosh, deFloatCosh)
 436 TCU_DECLARE_VECTOR_UNARY_FUNC(tanh, deFloatTanh)
 437 TCU_DECLARE_VECTOR_UNARY_FUNC(asinh, deFloatAsinh)
 438 TCU_DECLARE_VECTOR_UNARY_FUNC(acosh, deFloatAcosh)
 439 TCU_DECLARE_VECTOR_UNARY_FUNC(atanh, deFloatAtanh)
 440
 441 TCU_DECLARE_VECTOR_BINARY_FUNC(pow, deFloatPow)
 442 TCU_DECLARE_VECTOR_UNARY_FUNC(exp, deFloatExp)
 443 TCU_DECLARE_VECTOR_UNARY_FUNC(log, deFloatLog)
 444 TCU_DECLARE_VECTOR_UNARY_FUNC(exp2, deFloatExp2)
 445 TCU_DECLARE_VECTOR_UNARY_FUNC(log2, deFloatLog2)
 446 TCU_DECLARE_VECTOR_UNARY_FUNC(sqrt, deFloatSqrt)
 447 TCU_DECLARE_VECTOR_UNARY_FUNC(inverseSqrt, deFloatRsq)
 448
 449 TCU_DECLARE_VECTOR_UNARY_FUNC(abs, de::abs)
 450 TCU_DECLARE_VECTOR_UNARY_FUNC(sign, deFloatSign)
 451 TCU_DECLARE_VECTOR_UNARY_FUNC(floor, deFloatFloor)
 452 TCU_DECLARE_VECTOR_UNARY_FUNC(trunc, deFloatTrunc)
 453 TCU_DECLARE_VECTOR_UNARY_FUNC(roundToEven, roundToEven)
 454 TCU_DECLARE_VECTOR_UNARY_FUNC(ceil, deFloatCeil)
 455 TCU_DECLARE_VECTOR_UNARY_FUNC(fract, deFloatFrac)
 456 TCU_DECLARE_VECTOR_BINARY_FUNC(min, de::min)
 457 TCU_DECLARE_VECTOR_BINARY_FUNC(max, de::max)
 458 TCU_DECLARE_VECTOR_TERNARY_FUNC(clamp, de::clamp)
 459 TCU_DECLARE_VECTOR_TERNARY_FUNC(mix, deFloatMix)
 460 TCU_DECLARE_VECTOR_BINARY_FUNC(step, deFloatStep)
 461 TCU_DECLARE_VECTOR_TERNARY_FUNC(smoothStep, deFloatSmoothStep)
 462
 463 } // tcu
 464
 465 #endif // _TCUVECTORUTIL_HPP