1 #ifndef _GLSVERTEXARRAYTESTS_HPP 2 #define _GLSVERTEXARRAYTESTS_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program OpenGL (ES) Module 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 Vertex array and buffer tests 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuTestCase.hpp" 27 #include "tcuVector.hpp" 28 #include "tcuSurface.hpp" 29 #include "gluRenderContext.hpp" 30 #include "gluCallLogWrapper.hpp" 31 #include "tcuTestLog.hpp" 32 #include "gluShaderProgram.hpp" 33 #include "deFloat16.h" 34 #include "deMath.h" 35 #include "tcuFloat.hpp" 36 #include "tcuPixelFormat.hpp" 37 #include "sglrContext.hpp" 38 39 namespace sglr 40 { 41 42 class ReferenceContextBuffers; 43 class ReferenceContext; 44 class Context; 45 46 } // sglr 47 48 namespace deqp 49 { 50 namespace gls 51 { 52 53 class Array 54 { 55 public: 56 enum Target 57 { 58 // \note [mika] Are these actualy used somewhere? 59 TARGET_ELEMENT_ARRAY = 0, 60 TARGET_ARRAY, 61 62 TARGET_LAST 63 }; 64 65 enum InputType 66 { 67 INPUTTYPE_FLOAT = 0, 68 INPUTTYPE_FIXED, 69 INPUTTYPE_DOUBLE, 70 71 INPUTTYPE_BYTE, 72 INPUTTYPE_SHORT, 73 74 INPUTTYPE_UNSIGNED_BYTE, 75 INPUTTYPE_UNSIGNED_SHORT, 76 77 INPUTTYPE_INT, 78 INPUTTYPE_UNSIGNED_INT, 79 INPUTTYPE_HALF, 80 INPUTTYPE_UNSIGNED_INT_2_10_10_10, 81 INPUTTYPE_INT_2_10_10_10, 82 83 INPUTTYPE_LAST 84 }; 85 86 enum OutputType 87 { 88 OUTPUTTYPE_FLOAT = 0, 89 OUTPUTTYPE_VEC2, 90 OUTPUTTYPE_VEC3, 91 OUTPUTTYPE_VEC4, 92 93 OUTPUTTYPE_INT, 94 OUTPUTTYPE_UINT, 95 96 OUTPUTTYPE_IVEC2, 97 OUTPUTTYPE_IVEC3, 98 OUTPUTTYPE_IVEC4, 99 100 OUTPUTTYPE_UVEC2, 101 OUTPUTTYPE_UVEC3, 102 OUTPUTTYPE_UVEC4, 103 104 OUTPUTTYPE_LAST 105 }; 106 107 enum Usage 108 { 109 USAGE_DYNAMIC_DRAW = 0, 110 USAGE_STATIC_DRAW, 111 USAGE_STREAM_DRAW, 112 113 USAGE_STREAM_READ, 114 USAGE_STREAM_COPY, 115 116 USAGE_STATIC_READ, 117 USAGE_STATIC_COPY, 118 119 USAGE_DYNAMIC_READ, 120 USAGE_DYNAMIC_COPY, 121 122 USAGE_LAST 123 }; 124 125 enum Storage 126 { 127 STORAGE_USER = 0, 128 STORAGE_BUFFER, 129 130 STORAGE_LAST 131 }; 132 133 enum Primitive 134 { 135 PRIMITIVE_POINTS = 0, 136 PRIMITIVE_TRIANGLES, 137 PRIMITIVE_TRIANGLE_FAN, 138 PRIMITIVE_TRIANGLE_STRIP, 139 140 PRIMITIVE_LAST 141 }; 142 143 static std::string targetToString (Target target); 144 static std::string inputTypeToString (InputType type); 145 static std::string outputTypeToString (OutputType type); 146 static std::string usageTypeToString (Usage usage); 147 static std::string storageToString (Storage storage); 148 static std::string primitiveToString (Primitive primitive); 149 static int inputTypeSize (InputType type); 150 151 virtual ~Array (void) {} 152 virtual void data (Target target, int size, const char* data, Usage usage) = 0; 153 virtual void subdata (Target target, int offset, int size, const char* data) = 0; 154 virtual void bind (int attribNdx, int offset, int size, InputType inType, OutputType outType, bool normalized, int stride) = 0; 155 virtual void unBind (void) = 0; 156 157 virtual bool isBound (void) const = 0; 158 virtual int getComponentCount (void) const = 0; 159 virtual Target getTarget (void) const = 0; 160 virtual InputType getInputType (void) const = 0; 161 virtual OutputType getOutputType (void) const = 0; 162 virtual Storage getStorageType (void) const = 0; 163 virtual bool getNormalized (void) const = 0; 164 virtual int getStride (void) const = 0; 165 virtual int getAttribNdx (void) const = 0; 166 virtual void setAttribNdx (int attribNdx) = 0; 167 }; 168 169 class ContextArray : public Array 170 { 171 public: 172 ContextArray (Storage storage, sglr::Context& context); 173 virtual ~ContextArray (void); 174 virtual void data (Target target, int size, const char* data, Usage usage); 175 virtual void subdata (Target target, int offset, int size, const char* data); 176 virtual void bind (int attribNdx, int offset, int size, InputType inType, OutputType outType, bool normalized, int stride); 177 virtual void bindIndexArray (Array::Target storage); 178 virtual void unBind (void) { m_bound = false; } 179 virtual bool isBound (void) const { return m_bound; } 180 181 virtual int getComponentCount (void) const { return m_componentCount; } 182 virtual Array::Target getTarget (void) const { return m_target; } 183 virtual Array::InputType getInputType (void) const { return m_inputType; } 184 virtual Array::OutputType getOutputType (void) const { return m_outputType; } 185 virtual Array::Storage getStorageType (void) const { return m_storage; } 186 virtual bool getNormalized (void) const { return m_normalize; } 187 virtual int getStride (void) const { return m_stride; } 188 virtual int getAttribNdx (void) const { return m_attribNdx; } 189 virtual void setAttribNdx (int attribNdx) { m_attribNdx = attribNdx; } 190 191 void glBind (deUint32 loc); 192 static deUint32 targetToGL (Array::Target target); 193 static deUint32 usageToGL (Array::Usage usage); 194 static deUint32 inputTypeToGL (Array::InputType type); 195 static std::string outputTypeToGLType (Array::OutputType type); 196 static deUint32 primitiveToGL (Array::Primitive primitive); 197 198 private: 199 Storage m_storage; 200 sglr::Context& m_ctx; 201 deUint32 m_glBuffer; 202 203 bool m_bound; 204 int m_attribNdx; 205 int m_size; 206 char* m_data; 207 int m_componentCount; 208 Array::Target m_target; 209 Array::InputType m_inputType; 210 Array::OutputType m_outputType; 211 bool m_normalize; 212 int m_stride; 213 int m_offset; 214 }; 215 216 class ContextArrayPack 217 { 218 public: 219 ContextArrayPack (glu::RenderContext& renderCtx, sglr::Context& drawContext); 220 virtual ~ContextArrayPack (void); 221 virtual Array* getArray (int i); 222 virtual int getArrayCount (void); 223 virtual void newArray (Array::Storage storage); 224 virtual void render (Array::Primitive primitive, int firstVertex, int vertexCount, bool useVao, float coordScale, float colorScale); 225 226 const tcu::Surface& getSurface (void) const { return m_screen; } 227 private: 228 void updateProgram (void); 229 glu::RenderContext& m_renderCtx; 230 sglr::Context& m_ctx; 231 232 std::vector<ContextArray*> m_arrays; 233 sglr::ShaderProgram* m_program; 234 tcu::Surface m_screen; 235 }; 236 237 class GLValue 238 { 239 public: 240 template<class Type> 241 class WrappedType 242 { 243 public: 244 static WrappedType<Type> create (Type value) { WrappedType<Type> v; v.m_value = value; return v; } 245 static WrappedType<Type> fromFloat (float value) { WrappedType<Type> v; v.m_value = (Type)value; return v; } 246 inline Type getValue (void) const { return m_value; } 247 248 inline WrappedType<Type> operator+ (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value + other.getValue())); } 249 inline WrappedType<Type> operator* (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value * other.getValue())); } 250 inline WrappedType<Type> operator/ (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value / other.getValue())); } 251 inline WrappedType<Type> operator% (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value % other.getValue())); } 252 inline WrappedType<Type> operator- (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value - other.getValue())); } 253 254 inline WrappedType<Type>& operator+= (const WrappedType<Type>& other) { m_value += other.getValue(); return *this; } 255 inline WrappedType<Type>& operator*= (const WrappedType<Type>& other) { m_value *= other.getValue(); return *this; } 256 inline WrappedType<Type>& operator/= (const WrappedType<Type>& other) { m_value /= other.getValue(); return *this; } 257 inline WrappedType<Type>& operator-= (const WrappedType<Type>& other) { m_value -= other.getValue(); return *this; } 258 259 inline bool operator== (const WrappedType<Type>& other) const { return m_value == other.m_value; } 260 inline bool operator!= (const WrappedType<Type>& other) const { return m_value != other.m_value; } 261 inline bool operator< (const WrappedType<Type>& other) const { return m_value < other.m_value; } 262 inline bool operator> (const WrappedType<Type>& other) const { return m_value > other.m_value; } 263 inline bool operator<= (const WrappedType<Type>& other) const { return m_value <= other.m_value; } 264 inline bool operator>= (const WrappedType<Type>& other) const { return m_value >= other.m_value; } 265 266 inline operator Type (void) const { return m_value; } 267 template<class T> 268 inline T to (void) const { return (T)m_value; } 269 private: 270 Type m_value; 271 }; 272 273 template<class Type> 274 class WrappedFloatType 275 { 276 public: 277 static WrappedFloatType<Type> create (Type value) { WrappedFloatType<Type> v; v.m_value = value; return v; } 278 static WrappedFloatType<Type> fromFloat (float value) { WrappedFloatType<Type> v; v.m_value = (Type)value; return v; } 279 inline Type getValue (void) const { return m_value; } 280 281 inline WrappedFloatType<Type> operator+ (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value + other.getValue())); } 282 inline WrappedFloatType<Type> operator* (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value * other.getValue())); } 283 inline WrappedFloatType<Type> operator/ (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value / other.getValue())); } 284 inline WrappedFloatType<Type> operator% (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(deMod(m_value, other.getValue()))); } 285 inline WrappedFloatType<Type> operator- (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value - other.getValue())); } 286 287 inline WrappedFloatType<Type>& operator+= (const WrappedFloatType<Type>& other) { m_value += other.getValue(); return *this; } 288 inline WrappedFloatType<Type>& operator*= (const WrappedFloatType<Type>& other) { m_value *= other.getValue(); return *this; } 289 inline WrappedFloatType<Type>& operator/= (const WrappedFloatType<Type>& other) { m_value /= other.getValue(); return *this; } 290 inline WrappedFloatType<Type>& operator-= (const WrappedFloatType<Type>& other) { m_value -= other.getValue(); return *this; } 291 292 inline bool operator== (const WrappedFloatType<Type>& other) const { return m_value == other.m_value; } 293 inline bool operator!= (const WrappedFloatType<Type>& other) const { return m_value != other.m_value; } 294 inline bool operator< (const WrappedFloatType<Type>& other) const { return m_value < other.m_value; } 295 inline bool operator> (const WrappedFloatType<Type>& other) const { return m_value > other.m_value; } 296 inline bool operator<= (const WrappedFloatType<Type>& other) const { return m_value <= other.m_value; } 297 inline bool operator>= (const WrappedFloatType<Type>& other) const { return m_value >= other.m_value; } 298 299 inline operator Type (void) const { return m_value; } 300 template<class T> 301 inline T to (void) const { return (T)m_value; } 302 private: 303 Type m_value; 304 }; 305 306 typedef WrappedType<deInt16> Short; 307 typedef WrappedType<deUint16> Ushort; 308 309 typedef WrappedType<deInt8> Byte; 310 typedef WrappedType<deUint8> Ubyte; 311 312 typedef WrappedFloatType<float> Float; 313 typedef WrappedFloatType<double> Double; 314 315 typedef WrappedType<deInt32> Int; 316 typedef WrappedType<deUint32> Uint; 317 318 class Half 319 { 320 public: 321 static Half create (float value) { Half h; h.m_value = floatToHalf(value); return h; } 322 static Half fromFloat (float value) { Half h; h.m_value = floatToHalf(value); return h; } 323 inline deFloat16 getValue (void) const { return m_value; } 324 325 inline Half operator+ (const Half& other) const { return create(halfToFloat(m_value) + halfToFloat(other.getValue())); } 326 inline Half operator* (const Half& other) const { return create(halfToFloat(m_value) * halfToFloat(other.getValue())); } 327 inline Half operator/ (const Half& other) const { return create(halfToFloat(m_value) / halfToFloat(other.getValue())); } 328 inline Half operator% (const Half& other) const { return create(deFloatMod(halfToFloat(m_value), halfToFloat(other.getValue()))); } 329 inline Half operator- (const Half& other) const { return create(halfToFloat(m_value) - halfToFloat(other.getValue())); } 330 331 inline Half& operator+= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) + halfToFloat(m_value)); return *this; } 332 inline Half& operator*= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) * halfToFloat(m_value)); return *this; } 333 inline Half& operator/= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) / halfToFloat(m_value)); return *this; } 334 inline Half& operator-= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) - halfToFloat(m_value)); return *this; } 335 336 inline bool operator== (const Half& other) const { return m_value == other.m_value; } 337 inline bool operator!= (const Half& other) const { return m_value != other.m_value; } 338 inline bool operator< (const Half& other) const { return halfToFloat(m_value) < halfToFloat(other.m_value); } 339 inline bool operator> (const Half& other) const { return halfToFloat(m_value) > halfToFloat(other.m_value); } 340 inline bool operator<= (const Half& other) const { return halfToFloat(m_value) <= halfToFloat(other.m_value); } 341 inline bool operator>= (const Half& other) const { return halfToFloat(m_value) >= halfToFloat(other.m_value); } 342 343 template<class T> 344 inline T to (void) const { return (T)halfToFloat(m_value); } 345 346 inline static deFloat16 floatToHalf (float f); 347 inline static float halfToFloat (deFloat16 h); 348 private: 349 deFloat16 m_value; 350 }; 351 352 class Fixed 353 { 354 public: 355 static Fixed create (deInt32 value) { Fixed v; v.m_value = value; return v; } 356 static Fixed fromFloat (float value) { Fixed v; v.m_value = (deInt32)(value * 32768.0f); return v; } 357 inline deInt32 getValue (void) const { return m_value; } 358 359 inline Fixed operator+ (const Fixed& other) const { return create(m_value + other.getValue()); } 360 inline Fixed operator* (const Fixed& other) const { return create(m_value * other.getValue()); } 361 inline Fixed operator/ (const Fixed& other) const { return create(m_value / other.getValue()); } 362 inline Fixed operator% (const Fixed& other) const { return create(m_value % other.getValue()); } 363 inline Fixed operator- (const Fixed& other) const { return create(m_value - other.getValue()); } 364 365 inline Fixed& operator+= (const Fixed& other) { m_value += other.getValue(); return *this; } 366 inline Fixed& operator*= (const Fixed& other) { m_value *= other.getValue(); return *this; } 367 inline Fixed& operator/= (const Fixed& other) { m_value /= other.getValue(); return *this; } 368 inline Fixed& operator-= (const Fixed& other) { m_value -= other.getValue(); return *this; } 369 370 inline bool operator== (const Fixed& other) const { return m_value == other.m_value; } 371 inline bool operator!= (const Fixed& other) const { return m_value != other.m_value; } 372 inline bool operator< (const Fixed& other) const { return m_value < other.m_value; } 373 inline bool operator> (const Fixed& other) const { return m_value > other.m_value; } 374 inline bool operator<= (const Fixed& other) const { return m_value <= other.m_value; } 375 inline bool operator>= (const Fixed& other) const { return m_value >= other.m_value; } 376 377 inline operator deInt32 (void) const { return m_value; } 378 template<class T> 379 inline T to (void) const { return (T)m_value; } 380 private: 381 deInt32 m_value; 382 }; 383 384 // \todo [mika] This is pretty messy 385 GLValue (void) : type(Array::INPUTTYPE_LAST) {} 386 explicit GLValue (Float value) : type(Array::INPUTTYPE_FLOAT), fl(value) {} 387 explicit GLValue (Fixed value) : type(Array::INPUTTYPE_FIXED), fi(value) {} 388 explicit GLValue (Byte value) : type(Array::INPUTTYPE_BYTE), b(value) {} 389 explicit GLValue (Ubyte value) : type(Array::INPUTTYPE_UNSIGNED_BYTE), ub(value) {} 390 explicit GLValue (Short value) : type(Array::INPUTTYPE_SHORT), s(value) {} 391 explicit GLValue (Ushort value) : type(Array::INPUTTYPE_UNSIGNED_SHORT), us(value) {} 392 explicit GLValue (Int value) : type(Array::INPUTTYPE_INT), i(value) {} 393 explicit GLValue (Uint value) : type(Array::INPUTTYPE_UNSIGNED_INT), ui(value) {} 394 explicit GLValue (Half value) : type(Array::INPUTTYPE_HALF), h(value) {} 395 explicit GLValue (Double value) : type(Array::INPUTTYPE_DOUBLE), d(value) {} 396 397 float toFloat (void) const; 398 399 static GLValue getMaxValue (Array::InputType type); 400 static GLValue getMinValue (Array::InputType type); 401 402 Array::InputType type; 403 404 union 405 { 406 Float fl; 407 Fixed fi; 408 Double d; 409 Byte b; 410 Ubyte ub; 411 Short s; 412 Ushort us; 413 Int i; 414 Uint ui; 415 Half h; 416 }; 417 }; 418 419 class VertexArrayTest : public tcu::TestCase 420 { 421 public: 422 VertexArrayTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name ,const char* desc); 423 virtual ~VertexArrayTest (void); 424 virtual void init (void); 425 virtual void deinit (void); 426 427 protected: 428 VertexArrayTest (const VertexArrayTest& other); 429 VertexArrayTest& operator= (const VertexArrayTest& other); 430 431 void compare (void); 432 433 glu::RenderContext& m_renderCtx; 434 435 sglr::ReferenceContextBuffers* m_refBuffers; 436 sglr::ReferenceContext* m_refContext; 437 sglr::Context* m_glesContext; 438 439 ContextArrayPack* m_glArrayPack; 440 ContextArrayPack* m_rrArrayPack; 441 bool m_isOk; 442 443 int m_maxDiffRed; 444 int m_maxDiffGreen; 445 int m_maxDiffBlue; 446 }; 447 448 class MultiVertexArrayTest : public VertexArrayTest 449 { 450 public: 451 class Spec 452 { 453 public: 454 class ArraySpec 455 { 456 public: 457 ArraySpec (Array::InputType inputType, Array::OutputType outputType, Array::Storage storage, Array::Usage usage, int componetCount, int offset, int stride, bool normalize, GLValue min, GLValue max); 458 459 Array::InputType inputType; 460 Array::OutputType outputType; 461 Array::Storage storage; 462 Array::Usage usage; 463 int componentCount; 464 int offset; 465 int stride; 466 bool normalize; 467 GLValue min; 468 GLValue max; 469 }; 470 471 std::string getName (void) const; 472 std::string getDesc (void) const; 473 474 Array::Primitive primitive; 475 int drawCount; //!<Number of primitives to draw 476 int first; 477 478 std::vector<ArraySpec> arrays; 479 }; 480 481 MultiVertexArrayTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const Spec& spec, const char* name, const char* desc); 482 virtual ~MultiVertexArrayTest (void); 483 virtual IterateResult iterate (void); 484 485 private: 486 bool isUnalignedBufferOffsetTest (void) const; 487 bool isUnalignedBufferStrideTest (void) const; 488 489 Spec m_spec; 490 int m_iteration; 491 }; 492 493 inline deFloat16 GLValue::Half::floatToHalf (float f) 494 { 495 // No denorm support. 496 tcu::Float<deUint16, 5, 10, 15, tcu::FLOAT_HAS_SIGN> v(f); 497 DE_ASSERT(!v.isNaN() && !v.isInf()); 498 return v.bits(); 499 } 500 501 inline float GLValue::Half::halfToFloat (deFloat16 h) 502 { 503 return tcu::Float16((deUint16)h).asFloat(); 504 } 505 506 } // gls 507 } // deqp 508 509 #endif // _GLSVERTEXARRAYTESTS_HPP 510
