1 #ifndef _GLSBUFFERTESTUTIL_HPP 2 #define _GLSBUFFERTESTUTIL_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 Buffer test utilities. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "tcuTestCase.hpp" 28 #include "gluCallLogWrapper.hpp" 29 #include "gluObjectWrapper.hpp" 30 31 #include <vector> 32 #include <set> 33 34 namespace tcu 35 { 36 class TestLog; 37 } 38 39 namespace glu 40 { 41 class RenderContext; 42 class ShaderProgram; 43 } 44 45 namespace deqp 46 { 47 namespace gls 48 { 49 namespace BufferTestUtil 50 { 51 52 // Helper functions. 53 54 void fillWithRandomBytes (deUint8* ptr, int numBytes, deUint32 seed); 55 bool compareByteArrays (tcu::TestLog& log, const deUint8* resPtr, const deUint8* refPtr, int numBytes); 56 const char* getBufferTargetName (deUint32 target); 57 const char* getUsageHintName (deUint32 hint); 58 59 // Base class for buffer cases. 60 61 class BufferCase : public tcu::TestCase, public glu::CallLogWrapper 62 { 63 public: 64 BufferCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description); 65 virtual ~BufferCase (void); 66 67 void init (void); 68 void deinit (void); 69 70 deUint32 genBuffer (void); 71 void deleteBuffer (deUint32 buffer); 72 void checkError (void); 73 74 protected: 75 glu::RenderContext& m_renderCtx; 76 77 private: 78 // Resource handles for cleanup in case of unexpected iterate() termination. 79 std::set<deUint32> m_allocatedBuffers; 80 }; 81 82 // Reference buffer. 83 84 class ReferenceBuffer 85 { 86 public: 87 ReferenceBuffer (void) {} 88 ~ReferenceBuffer (void) {} 89 90 void setSize (int numBytes); 91 void setData (int numBytes, const deUint8* bytes); 92 void setSubData (int offset, int numBytes, const deUint8* bytes); 93 94 deUint8* getPtr (int offset = 0) { return &m_data[offset]; } 95 const deUint8* getPtr (int offset = 0) const { return &m_data[offset]; } 96 97 private: 98 std::vector<deUint8> m_data; 99 }; 100 101 // Buffer writer system. 102 103 enum WriteType 104 { 105 WRITE_BUFFER_SUB_DATA = 0, 106 WRITE_BUFFER_WRITE_MAP, 107 WRITE_TRANSFORM_FEEDBACK, 108 WRITE_PIXEL_PACK, 109 110 WRITE_LAST 111 }; 112 113 const char* getWriteTypeDescription (WriteType type); 114 115 class BufferWriterBase : protected glu::CallLogWrapper 116 { 117 public: 118 BufferWriterBase (glu::RenderContext& renderCtx, tcu::TestLog& log); 119 virtual ~BufferWriterBase (void) {} 120 121 virtual int getMinSize (void) const = DE_NULL; 122 virtual int getAlignment (void) const = DE_NULL; 123 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes) = DE_NULL; 124 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint); 125 126 protected: 127 glu::RenderContext& m_renderCtx; 128 129 private: 130 BufferWriterBase (const BufferWriterBase& other); 131 BufferWriterBase& operator= (const BufferWriterBase& other); 132 }; 133 134 class BufferWriter 135 { 136 public: 137 BufferWriter (glu::RenderContext& renderCtx, tcu::TestLog& log, WriteType writeType); 138 ~BufferWriter (void); 139 140 int getMinSize (void) const { return m_writer->getMinSize(); } 141 int getAlignment (void) const { return m_writer->getAlignment(); } 142 void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes); 143 void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint); 144 145 private: 146 BufferWriter (const BufferWriter& other); 147 BufferWriter& operator= (const BufferWriter& other); 148 149 BufferWriterBase* m_writer; 150 }; 151 152 class BufferSubDataWriter : public BufferWriterBase 153 { 154 public: 155 BufferSubDataWriter (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferWriterBase(renderCtx, log) {} 156 ~BufferSubDataWriter (void) {} 157 158 int getMinSize (void) const { return 1; } 159 int getAlignment (void) const { return 1; } 160 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes); 161 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target); 162 }; 163 164 class BufferWriteMapWriter : public BufferWriterBase 165 { 166 public: 167 BufferWriteMapWriter (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferWriterBase(renderCtx, log) {} 168 ~BufferWriteMapWriter (void) {} 169 170 int getMinSize (void) const { return 1; } 171 int getAlignment (void) const { return 1; } 172 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes); 173 virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target); 174 }; 175 176 // Buffer verifier system. 177 178 enum VerifyType 179 { 180 VERIFY_AS_VERTEX_ARRAY = 0, 181 VERIFY_AS_INDEX_ARRAY, 182 VERIFY_AS_UNIFORM_BUFFER, 183 VERIFY_AS_PIXEL_UNPACK_BUFFER, 184 VERIFY_BUFFER_READ_MAP, 185 186 VERIFY_LAST 187 }; 188 189 const char* getVerifyTypeDescription (VerifyType type); 190 191 class BufferVerifierBase : public glu::CallLogWrapper 192 { 193 public: 194 BufferVerifierBase (glu::RenderContext& renderCtx, tcu::TestLog& log); 195 virtual ~BufferVerifierBase (void) {} 196 197 virtual int getMinSize (void) const = DE_NULL; 198 virtual int getAlignment (void) const = DE_NULL; 199 virtual bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes) = DE_NULL; 200 virtual bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint); 201 202 protected: 203 glu::RenderContext& m_renderCtx; 204 tcu::TestLog& m_log; 205 206 private: 207 BufferVerifierBase (const BufferVerifierBase& other); 208 BufferVerifierBase& operator= (const BufferVerifierBase& other); 209 }; 210 211 class BufferVerifier 212 { 213 public: 214 BufferVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log, VerifyType verifyType); 215 ~BufferVerifier (void); 216 217 int getMinSize (void) const { return m_verifier->getMinSize(); } 218 int getAlignment (void) const { return m_verifier->getAlignment(); } 219 220 // \note Offset is applied to reference pointer as well. 221 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes); 222 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint); 223 224 private: 225 BufferVerifier (const BufferVerifier& other); 226 BufferVerifier& operator= (const BufferVerifier& other); 227 228 BufferVerifierBase* m_verifier; 229 }; 230 231 class BufferMapVerifier : public BufferVerifierBase 232 { 233 public: 234 BufferMapVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferVerifierBase(renderCtx, log) {} 235 ~BufferMapVerifier (void) {} 236 237 int getMinSize (void) const { return 1; } 238 int getAlignment (void) const { return 1; } 239 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes); 240 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 target); 241 }; 242 243 class VertexArrayVerifier : public BufferVerifierBase 244 { 245 public: 246 VertexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log); 247 ~VertexArrayVerifier (void); 248 249 int getMinSize (void) const { return 3*4; } 250 int getAlignment (void) const { return 1; } 251 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes); 252 253 private: 254 glu::ShaderProgram* m_program; 255 deUint32 m_posLoc; 256 deUint32 m_byteVecLoc; 257 258 deUint32 m_vao; 259 deUint32 m_positionBuf; 260 deUint32 m_indexBuf; 261 }; 262 263 class IndexArrayVerifier : public BufferVerifierBase 264 { 265 public: 266 IndexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log); 267 ~IndexArrayVerifier (void); 268 269 int getMinSize (void) const { return 2; } 270 int getAlignment (void) const { return 1; } 271 bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes); 272 273 private: 274 glu::ShaderProgram* m_program; 275 deUint32 m_posLoc; 276 deUint32 m_colorLoc; 277 278 deUint32 m_vao; 279 deUint32 m_positionBuf; 280 deUint32 m_colorBuf; 281 }; 282 283 } // BufferTestUtil 284 } // gls 285 } // deqp 286 287 #endif // _GLSBUFFERTESTUTIL_HPP 288
