1 #ifndef _TCUVECTOR_HPP 2 #define _TCUVECTOR_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 Generic vector template. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "tcuVectorType.hpp" 28 #include "deInt32.h" 29 30 #include <ostream> 31 32 namespace tcu 33 { 34 35 // Accessor proxy class for Vectors. 36 template <typename T, int VecSize, int Size> 37 class VecAccess 38 { 39 public: 40 explicit VecAccess (Vector<T, VecSize>& v, int x, int y); 41 explicit VecAccess (Vector<T, VecSize>& v, int x, int y, int z); 42 explicit VecAccess (Vector<T, VecSize>& v, int x, int y, int z, int w); 43 44 VecAccess& operator= (const Vector<T, Size>& v); 45 46 operator Vector<T, Size> (void) const; 47 48 private: 49 Vector<T, VecSize>& m_vector; 50 int m_index[Size]; 51 }; 52 53 template <typename T, int VecSize, int Size> 54 VecAccess<T, VecSize, Size>::VecAccess (Vector<T, VecSize>& v, int x, int y) 55 : m_vector(v) 56 { 57 DE_STATIC_ASSERT(Size == 2); 58 m_index[0] = x; 59 m_index[1] = y; 60 } 61 62 template <typename T, int VecSize, int Size> 63 VecAccess<T, VecSize, Size>::VecAccess (Vector<T, VecSize>& v, int x, int y, int z) 64 : m_vector(v) 65 { 66 DE_STATIC_ASSERT(Size == 3); 67 m_index[0] = x; 68 m_index[1] = y; 69 m_index[2] = z; 70 } 71 72 template <typename T, int VecSize, int Size> 73 VecAccess<T, VecSize, Size>::VecAccess (Vector<T, VecSize>& v, int x, int y, int z, int w) 74 : m_vector(v) 75 { 76 DE_STATIC_ASSERT(Size == 4); 77 m_index[0] = x; 78 m_index[1] = y; 79 m_index[2] = z; 80 m_index[3] = w; 81 } 82 83 template <typename T, int VecSize, int Size> 84 VecAccess<T, VecSize, Size>& VecAccess<T, VecSize, Size>::operator= (const Vector<T, Size>& v) 85 { 86 for (int i = 0; i < Size; i++) 87 m_vector.m_data[m_index[i]] = v.m_data[i]; 88 return *this; 89 } 90 91 // Vector class. 92 template <typename T, int Size> 93 class Vector 94 { 95 public: 96 typedef T Element; 97 enum 98 { 99 SIZE = Size, 100 }; 101 102 T m_data[Size]; 103 104 // Constructors. 105 explicit Vector (void); 106 explicit Vector (T s_); // replicate 107 Vector (T x_, T y_); 108 Vector (T x_, T y_, T z_); 109 Vector (T x_, T y_, T z_, T w_); 110 Vector (const Vector<T, Size>& v); 111 Vector (const T (&v)[Size]); 112 113 const T* getPtr (void) const { return &m_data[0]; } 114 T* getPtr (void) { return &m_data[0]; } 115 116 // Read-only access. 117 T x (void) const { return m_data[0]; } 118 T y (void) const { DE_STATIC_ASSERT(Size >= 2); return m_data[1]; } 119 T z (void) const { DE_STATIC_ASSERT(Size >= 3); return m_data[2]; } 120 T w (void) const { DE_STATIC_ASSERT(Size >= 4); return m_data[3]; } 121 122 // Read-write access. 123 T& x (void) { return m_data[0]; } 124 T& y (void) { DE_STATIC_ASSERT(Size >= 2); return m_data[1]; } 125 T& z (void) { DE_STATIC_ASSERT(Size >= 3); return m_data[2]; } 126 T& w (void) { DE_STATIC_ASSERT(Size >= 4); return m_data[3]; } 127 128 // Writable accessors. 129 VecAccess<T, Size, 2> xy (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 0, 1); } 130 VecAccess<T, Size, 2> xz (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 0, 2); } 131 VecAccess<T, Size, 2> xw (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 0, 3); } 132 VecAccess<T, Size, 2> yz (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 1, 2); } 133 VecAccess<T, Size, 2> yw (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 1, 3); } 134 VecAccess<T, Size, 2> zw (void) { DE_ASSERT(Size >= 2); return VecAccess<T, Size, 2>(*this, 2, 3); } 135 VecAccess<T, Size, 3> xyz (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 0, 1, 2); } 136 VecAccess<T, Size, 3> xyw (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 0, 1, 3); } 137 VecAccess<T, Size, 3> xzw (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 0, 2, 3); } 138 VecAccess<T, Size, 3> zyx (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 2, 1, 0); } 139 VecAccess<T, Size, 3> yzw (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 1, 2, 3); } 140 VecAccess<T, Size, 3> wzy (void) { DE_ASSERT(Size >= 3); return VecAccess<T, Size, 3>(*this, 3, 2, 1); } 141 VecAccess<T, Size, 4> xyzw (void) { DE_ASSERT(Size >= 4); return VecAccess<T, Size, 4>(*this, 0, 1, 2, 3); } 142 143 // Swizzles. 144 Vector<T, 1> swizzle (int a) const { DE_ASSERT(a >= 0 && a < Size); return Vector<T, 1>(m_data[a]); } 145 Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } 146 Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } 147 Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } 148 149 Vector<float, Size> asFloat (void) const { return cast<float>(); } 150 Vector<int, Size> asInt (void) const { return cast<int>(); } 151 Vector<deUint32, Size> asUint (void) const { return cast<deUint32>(); } 152 Vector<bool, Size> asBool (void) const { return cast<bool>(); } 153 154 // Operators. 155 Vector<T, Size>& operator+= (const Vector<T, Size>& v); 156 Vector<T, Size>& operator-= (const Vector<T, Size>& v); 157 158 const T& operator[] (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Size)); return m_data[ndx]; } 159 T& operator[] (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Size)); return m_data[ndx]; } 160 161 bool operator== (const Vector<T, Size>& v) const { for (int i = 0; i < Size; i++) if (m_data[i] != v.m_data[i]) return false; return true; } 162 bool operator!= (const Vector<T, Size>& v) const { return !(*this == v); } 163 164 // Miscellaneous conversions. 165 template<typename NewT> 166 Vector<NewT, Size> cast (void) const; 167 168 template <int NewSize> 169 Vector<T, NewSize> toWidth (void) const; 170 } DE_WARN_UNUSED_TYPE; 171 172 template <typename T, int Size> 173 inline Vector<T, Size>::Vector (void) 174 { 175 for (int i = 0; i < Size; i++) 176 m_data[i] = T(); 177 } 178 179 template <typename T, int Size> 180 inline Vector<T, Size>::Vector (T s) 181 { 182 for (int i = 0; i < Size; i++) 183 m_data[i] = s; 184 } 185 186 template <typename T, int Size> 187 inline Vector<T, Size>::Vector (T x_, T y_) 188 { 189 DE_STATIC_ASSERT(Size == 2); 190 m_data[0] = x_; 191 m_data[1] = y_; 192 } 193 194 template <typename T, int Size> 195 inline Vector<T, Size>::Vector (T x_, T y_, T z_) 196 { 197 DE_STATIC_ASSERT(Size == 3); 198 m_data[0] = x_; 199 m_data[1] = y_; 200 m_data[2] = z_; 201 } 202 203 template <typename T, int Size> 204 inline Vector<T, Size>::Vector (T x_, T y_, T z_, T w_) 205 { 206 DE_STATIC_ASSERT(Size == 4); 207 m_data[0] = x_; 208 m_data[1] = y_; 209 m_data[2] = z_; 210 m_data[3] = w_; 211 } 212 213 template <typename T, int Size> 214 inline Vector<T, Size>::Vector (const Vector<T, Size>& v) 215 { 216 for (int i = 0; i < Size; i++) 217 m_data[i] = v.m_data[i]; 218 } 219 220 template <typename T, int Size> 221 inline Vector<T, Size>::Vector (const T (&v)[Size]) 222 { 223 for (int i = 0; i < Size; i++) 224 m_data[i] = v[i]; 225 } 226 227 // VecAccess to Vector cast. 228 template <typename T, int VecSize, int Size> 229 VecAccess<T, VecSize, Size>::operator Vector<T, Size> (void) const 230 { 231 Vector<T, Size> vec; 232 for (int i = 0; i < Size; i++) 233 vec.m_data[i] = m_vector.m_data[m_index[i]]; 234 return vec; 235 } 236 237 // Type cast. 238 template <typename T, int Size> 239 template <typename NewT> 240 inline Vector<NewT, Size> Vector<T, Size>::cast (void) const 241 { 242 Vector<NewT, Size> res; 243 for (int i = 0; i < Size; i++) 244 res.m_data[i] = NewT(m_data[i]); 245 return res; 246 } 247 248 // Size cast. 249 template <typename T, int Size> 250 template <int NewSize> 251 inline Vector<T, NewSize> Vector<T, Size>::toWidth (void) const 252 { 253 Vector<T, NewSize> res; 254 int i; 255 for (i = 0; i < deMin32(Size, NewSize); i++) 256 res.m_data[i] = m_data[i]; 257 for (; i < NewSize; i++) 258 res.m_data[i] = T(0); 259 return res; 260 } 261 262 // Operators. 263 264 template <typename T, int Size> 265 inline Vector<T, Size> operator- (const Vector<T, Size>& a) 266 { 267 Vector<T, Size> res; 268 for (int i = 0; i < Size; i++) 269 res.m_data[i] = -a.m_data[i]; 270 return res; 271 } 272 273 template <typename T, int Size> 274 inline Vector<T, Size> operator+ (const Vector<T, Size>& a, const Vector<T, Size>& b) 275 { 276 Vector<T, Size> res; 277 for (int i = 0; i < Size; i++) 278 res.m_data[i] = a.m_data[i] + b.m_data[i]; 279 return res; 280 } 281 282 template <typename T, int Size> 283 inline Vector<T, Size> operator- (const Vector<T, Size>& a, const Vector<T, Size>& b) 284 { 285 Vector<T, Size> res; 286 for (int i = 0; i < Size; i++) 287 res.m_data[i] = a.m_data[i] - b.m_data[i]; 288 return res; 289 } 290 291 template <typename T, int Size> 292 inline Vector<T, Size> operator* (const Vector<T, Size>& a, const Vector<T, Size>& b) 293 { 294 Vector<T, Size> res; 295 for (int i = 0; i < Size; i++) 296 res.m_data[i] = a.m_data[i] * b.m_data[i]; 297 return res; 298 } 299 300 template <typename T, int Size> 301 inline Vector<T, Size> operator/ (const Vector<T, Size>& a, const Vector<T, Size>& b) 302 { 303 Vector<T, Size> res; 304 for (int i = 0; i < Size; i++) 305 res.m_data[i] = a.m_data[i] / b.m_data[i]; 306 return res; 307 } 308 309 template <typename T, int Size> 310 inline Vector<T, Size> operator<< (const Vector<T, Size>& a, const Vector<T, Size>& b) 311 { 312 Vector<T, Size> res; 313 for (int i = 0; i < Size; i++) 314 res.m_data[i] = a.m_data[i] << b.m_data[i]; 315 return res; 316 } 317 318 template <typename T, int Size> 319 inline Vector<T, Size> operator>> (const Vector<T, Size>& a, const Vector<T, Size>& b) 320 { 321 Vector<T, Size> res; 322 for (int i = 0; i < Size; i++) 323 res.m_data[i] = a.m_data[i] >> b.m_data[i]; 324 return res; 325 } 326 327 template <typename T, int Size> 328 inline Vector<T, Size> operator* (T s, const Vector<T, Size>& a) 329 { 330 Vector<T, Size> res; 331 for (int i = 0; i < Size; i++) 332 res.m_data[i] = s * a.m_data[i]; 333 return res; 334 } 335 336 template <typename T, int Size> 337 inline Vector<T, Size> operator+ (T s, const Vector<T, Size>& a) 338 { 339 Vector<T, Size> res; 340 for (int i = 0; i < Size; i++) 341 res.m_data[i] = s + a.m_data[i]; 342 return res; 343 } 344 345 template <typename T, int Size> 346 inline Vector<T, Size> operator- (T s, const Vector<T, Size>& a) 347 { 348 Vector<T, Size> res; 349 for (int i = 0; i < Size; i++) 350 res.m_data[i] = s - a.m_data[i]; 351 return res; 352 } 353 354 template <typename T, int Size> 355 inline Vector<T, Size> operator- (const Vector<T, Size>& a, T s) 356 { 357 Vector<T, Size> res; 358 for (int i = 0; i < Size; i++) 359 res.m_data[i] = a.m_data[i] - s; 360 return res; 361 } 362 363 template <typename T, int Size> 364 inline Vector<T, Size> operator/ (T s, const Vector<T, Size>& a) 365 { 366 Vector<T, Size> res; 367 for (int i = 0; i < Size; i++) 368 res.m_data[i] = s / a.m_data[i]; 369 return res; 370 } 371 372 template <typename T, int Size> 373 inline Vector<T, Size> operator* (const Vector<T, Size>& a, T s) { return s * a; } 374 375 template <typename T, int Size> 376 inline Vector<T, Size> operator+ (const Vector<T, Size>& a, T s) { return s + a; } 377 378 template <typename T, int Size> 379 inline Vector<T, Size> operator/ (const Vector<T, Size>& a, T s) 380 { 381 Vector<T, Size> res; 382 for (int i = 0; i < Size; i++) 383 res.m_data[i] = a.m_data[i] / s; 384 return res; 385 } 386 387 template <typename T, int Size> 388 inline Vector<T, Size>& Vector<T, Size>::operator+= (const Vector<T, Size>& v) 389 { 390 for (int i = 0; i < Size; i++) 391 m_data[i] += v.m_data[i]; 392 return *this; 393 } 394 395 template <typename T, int Size> 396 inline Vector<T, Size>& Vector<T, Size>::operator-= (const Vector<T, Size>& v) 397 { 398 for (int i = 0; i < Size; i++) 399 m_data[i] -= v.m_data[i]; 400 return *this; 401 } 402 403 // Stream operator. 404 template <typename T, int Size> 405 std::ostream& operator<< (std::ostream& stream, const tcu::Vector<T, Size>& vec) 406 { 407 stream << "("; 408 for (int i = 0; i < Size; i++) 409 { 410 if (i != 0) 411 stream << ", "; 412 stream << vec.m_data[i]; 413 } 414 stream << ")"; 415 return stream; 416 } 417 418 } // tcu 419 420 #endif // _TCUVECTOR_HPP 421
