Lower correlation threshold in flush-finish tests again am: 6455e6f987 am: 84373d7748...
[platform/upstream/VK-GL-CTS.git] / framework / opengl / gluDrawUtil.hpp
1 #ifndef _GLUDRAWUTIL_HPP
2 #define _GLUDRAWUTIL_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program OpenGL Utilities
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 Draw call utilities.
24  *
25  * Draw call utilities provide an abstraction for commonly used draw calls.
26  * The objective of that abstraction is to allow moving data to buffers
27  * and state to VAOs automatically if target context doesn't support
28  * user pointers or default VAOs.
29  *//*--------------------------------------------------------------------*/
30
31 #include "gluDefs.hpp"
32
33 #include <string>
34
35 namespace glu
36 {
37
38 class RenderContext;
39
40 enum VertexComponentType
41 {
42         // Standard types: all conversion types apply.
43         VTX_COMP_UNSIGNED_INT8          = 0,
44         VTX_COMP_UNSIGNED_INT16,
45         VTX_COMP_UNSIGNED_INT32,
46         VTX_COMP_SIGNED_INT8,
47         VTX_COMP_SIGNED_INT16,
48         VTX_COMP_SIGNED_INT32,
49
50         // Special types: only CONVERT_NONE is allowed.
51         VTX_COMP_FIXED,
52         VTX_COMP_HALF_FLOAT,
53         VTX_COMP_FLOAT,
54
55         VTX_COMP_TYPE_LAST
56 };
57
58 enum VertexComponentConversion
59 {
60         VTX_COMP_CONVERT_NONE = 0,                              //!< No conversion: integer types, or floating-point values.
61         VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT,    //!< Normalize integers to range [0,1] or [-1,1] depending on type.
62         VTX_COMP_CONVERT_CAST_TO_FLOAT,                 //!< Convert to floating-point directly.
63
64         VTX_COMP_CONVERT_LAST
65 };
66
67 enum IndexType
68 {
69         INDEXTYPE_UINT8,
70         INDEXTYPE_UINT16,
71         INDEXTYPE_UINT32,
72
73         INDEXTYPE_LAST
74 };
75
76 enum PrimitiveType
77 {
78         PRIMITIVETYPE_TRIANGLES = 0,
79         PRIMITIVETYPE_TRIANGLE_STRIP,
80         PRIMITIVETYPE_TRIANGLE_FAN,
81
82         PRIMITIVETYPE_LINES,
83         PRIMITIVETYPE_LINE_STRIP,
84         PRIMITIVETYPE_LINE_LOOP,
85
86         PRIMITIVETYPE_POINTS,
87
88         PRIMITIVETYPE_PATCHES,
89
90         PRIMITIVETYPE_LAST
91 };
92
93 struct BindingPoint
94 {
95         enum Type
96         {
97                 TYPE_LOCATION = 0,                      //!< Binding by numeric location.
98                 TYPE_NAME,                                      //!< Binding by input name.
99
100                 TYPE_LAST
101         };
102
103         Type                    type;                   //!< Binding type (name or location).
104         std::string             name;                   //!< Input name, or empty if is not binding by name.
105         int                             location;               //!< Input location, or offset to named location if binding by name.
106
107                                 BindingPoint (void)                                                                                     : type(TYPE_LAST), location (0) {}
108         explicit        BindingPoint (int location_)                                                            : type(TYPE_LOCATION), location(location_) {}
109         explicit        BindingPoint (const std::string& name_, int location_ = 0)      : type(TYPE_NAME), name(name_), location(location_) {}
110 };
111
112 struct VertexArrayPointer
113 {
114         VertexComponentType                     componentType;  //!< Component type.
115         VertexComponentConversion       convert;                //!< Component conversion type.
116         int                                                     numComponents;  //!< Number of components per element.
117         int                                                     numElements;    //!< Number of elements in total.
118         int                                                     stride;                 //!< Element stride.
119
120         const void*                                     data;                   //!< Data pointer.
121
122         VertexArrayPointer (VertexComponentType componentType_, VertexComponentConversion convert_, int numComponents_, int numElements_, int stride_, const void* data_)
123                 : componentType (componentType_)
124                 , convert               (convert_)
125                 , numComponents (numComponents_)
126                 , numElements   (numElements_)
127                 , stride                (stride_)
128                 , data                  (data_)
129         {
130         }
131
132         VertexArrayPointer (void)
133                 : componentType (VTX_COMP_TYPE_LAST)
134                 , convert               (VTX_COMP_CONVERT_LAST)
135                 , numComponents (0)
136                 , numElements   (0)
137                 , stride                (0)
138                 , data                  (0)
139         {
140         }
141 } DE_WARN_UNUSED_TYPE;
142
143 struct VertexArrayBinding
144 {
145         BindingPoint            binding;
146         VertexArrayPointer      pointer;
147
148         VertexArrayBinding (const BindingPoint& binding_, const VertexArrayPointer& pointer_)
149                 : binding       (binding_)
150                 , pointer       (pointer_)
151         {
152         }
153
154         VertexArrayBinding (void)
155         {
156         }
157 } DE_WARN_UNUSED_TYPE;
158
159 struct PrimitiveList
160 {
161         PrimitiveType           type;                   //!< Primitive type.
162         int                                     numElements;    //!< Number of elements to be drawn.
163         IndexType                       indexType;              //!< Index type or INDEXTYPE_LAST if not used
164         const void*                     indices;                //!< Index list or DE_NULL if not used.
165
166         PrimitiveList (PrimitiveType type_, int numElements_)
167                 : type                  (type_)
168                 , numElements   (numElements_)
169                 , indexType             (INDEXTYPE_LAST)
170                 , indices               (0)
171         {
172         }
173
174         PrimitiveList (PrimitiveType type_, int numElements_, IndexType indexType_, const void* indices_)
175                 : type                  (type_)
176                 , numElements   (numElements_)
177                 , indexType             (indexType_)
178                 , indices               (indices_)
179         {
180         }
181
182         PrimitiveList (void)
183                 : type                  (PRIMITIVETYPE_LAST)
184                 , numElements   (0)
185                 , indexType             (INDEXTYPE_LAST)
186                 , indices               (0)
187         {
188         }
189 } DE_WARN_UNUSED_TYPE;
190
191 class DrawUtilCallback
192 {
193 public:
194         virtual void    beforeDrawCall  (void) { }
195         virtual void    afterDrawCall   (void) { }
196 };
197
198 void    draw                                    (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback = DE_NULL);
199
200 void    drawFromUserPointers    (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback = DE_NULL);
201 void    drawFromBuffers                 (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback = DE_NULL);
202 void    drawFromVAOBuffers              (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback = DE_NULL);
203
204 // Shorthands for PrimitiveList
205 namespace pr
206 {
207
208 #define DECLARE_PR_CTOR(NAME, TYPE)                                                                             \
209 inline PrimitiveList NAME (int numElements)                                                             \
210 {                                                                                                                                               \
211         return PrimitiveList(TYPE, numElements);                                                        \
212 }                                                                                                                                               \
213 inline PrimitiveList NAME (int numElements, const deUint8* indices)             \
214 {                                                                                                                                               \
215         return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT8, indices);      \
216 }                                                                                                                                               \
217 inline PrimitiveList NAME (int numElements, const deUint16* indices)    \
218 {                                                                                                                                               \
219         return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT16, indices);     \
220 }                                                                                                                                               \
221 inline PrimitiveList NAME (int numElements, const deUint32* indices)    \
222 {                                                                                                                                               \
223         return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT32, indices);     \
224 }                                                                                                                                               \
225 struct DeclarePRCtor##NAME##Unused_s { int unused; }
226
227 DECLARE_PR_CTOR(Triangles,              PRIMITIVETYPE_TRIANGLES);
228 DECLARE_PR_CTOR(TriangleStrip,  PRIMITIVETYPE_TRIANGLE_STRIP);
229 DECLARE_PR_CTOR(TriangleFan,    PRIMITIVETYPE_TRIANGLE_FAN);
230
231 DECLARE_PR_CTOR(Lines,                  PRIMITIVETYPE_LINES);
232 DECLARE_PR_CTOR(LineStrip,              PRIMITIVETYPE_LINE_STRIP);
233 DECLARE_PR_CTOR(LineLineLoop,   PRIMITIVETYPE_LINE_LOOP);
234
235 DECLARE_PR_CTOR(Points,                 PRIMITIVETYPE_POINTS);
236
237 DECLARE_PR_CTOR(Patches,                PRIMITIVETYPE_PATCHES);
238
239 } // pr
240
241 // Shorthands for VertexArrayBinding
242 namespace va
243 {
244
245 #define DECLARE_VA_CTOR(NAME, DATATYPE, TYPE, CONVERT)                                                                                                                                                                          \
246 inline VertexArrayBinding NAME (const std::string& name, int offset, int numComponents, int numElements, int stride, const DATATYPE* data)      \
247 {                                                                                                                                                                                                                                                                                       \
248         return VertexArrayBinding(BindingPoint(name, offset), VertexArrayPointer(TYPE, CONVERT, numComponents, numElements, stride, data));             \
249 }                                                                                                                                                                                                                                                                                       \
250 inline VertexArrayBinding NAME (const std::string& name, int numComponents, int numElements, int stride, const DATATYPE* data)                          \
251 {                                                                                                                                                                                                                                                                                       \
252         return NAME(name, 0, numComponents, numElements, stride, data);                                                                                                                                                 \
253 }                                                                                                                                                                                                                                                                                       \
254 inline VertexArrayBinding NAME (int location, int numComponents, int numElements, int stride, const DATATYPE* data)                                                     \
255 {                                                                                                                                                                                                                                                                                       \
256         return VertexArrayBinding(BindingPoint(location), VertexArrayPointer(TYPE, CONVERT, numComponents, numElements, stride, data));                 \
257 }                                                                                                                                                                                                                                                                                       \
258 struct DeclareVACtor##NAME##Unused_s { int unused; }
259
260 // Integer types
261 DECLARE_VA_CTOR(Uint8,                  deUint8,                VTX_COMP_UNSIGNED_INT8,         VTX_COMP_CONVERT_NONE);
262 DECLARE_VA_CTOR(Uint16,                 deUint16,               VTX_COMP_UNSIGNED_INT16,        VTX_COMP_CONVERT_NONE);
263 DECLARE_VA_CTOR(Uint32,                 deUint32,               VTX_COMP_UNSIGNED_INT32,        VTX_COMP_CONVERT_NONE);
264 DECLARE_VA_CTOR(Int8,                   deInt8,                 VTX_COMP_SIGNED_INT8,           VTX_COMP_CONVERT_NONE);
265 DECLARE_VA_CTOR(Int16,                  deInt16,                VTX_COMP_SIGNED_INT16,          VTX_COMP_CONVERT_NONE);
266 DECLARE_VA_CTOR(Int32,                  deInt32,                VTX_COMP_SIGNED_INT32,          VTX_COMP_CONVERT_NONE);
267
268 // Normalized integers.
269 DECLARE_VA_CTOR(Unorm8,                 deUint8,                VTX_COMP_UNSIGNED_INT8,         VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
270 DECLARE_VA_CTOR(Unorm16,                deUint16,               VTX_COMP_UNSIGNED_INT16,        VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
271 DECLARE_VA_CTOR(Unorm32,                deUint32,               VTX_COMP_UNSIGNED_INT32,        VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
272 DECLARE_VA_CTOR(Snorm8,                 deInt8,                 VTX_COMP_SIGNED_INT8,           VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
273 DECLARE_VA_CTOR(Snorm16,                deInt16,                VTX_COMP_SIGNED_INT16,          VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
274 DECLARE_VA_CTOR(Snorm32,                deInt32,                VTX_COMP_SIGNED_INT32,          VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
275
276 // Integers converted to float.
277 DECLARE_VA_CTOR(Uint8Float,             deUint8,                VTX_COMP_UNSIGNED_INT8,         VTX_COMP_CONVERT_CAST_TO_FLOAT);
278 DECLARE_VA_CTOR(Uint16Float,    deUint16,               VTX_COMP_UNSIGNED_INT16,        VTX_COMP_CONVERT_CAST_TO_FLOAT);
279 DECLARE_VA_CTOR(Uint32Float,    deUint32,               VTX_COMP_UNSIGNED_INT32,        VTX_COMP_CONVERT_CAST_TO_FLOAT);
280 DECLARE_VA_CTOR(Int8Float,              deInt8,                 VTX_COMP_SIGNED_INT8,           VTX_COMP_CONVERT_CAST_TO_FLOAT);
281 DECLARE_VA_CTOR(Int16Float,             deInt16,                VTX_COMP_SIGNED_INT16,          VTX_COMP_CONVERT_CAST_TO_FLOAT);
282 DECLARE_VA_CTOR(Int32Float,             deInt32,                VTX_COMP_SIGNED_INT32,          VTX_COMP_CONVERT_CAST_TO_FLOAT);
283
284 // Special types.
285 DECLARE_VA_CTOR(Fixed,                  void,                   VTX_COMP_FIXED,                         VTX_COMP_CONVERT_NONE);
286 DECLARE_VA_CTOR(Half,                   void,                   VTX_COMP_HALF_FLOAT,            VTX_COMP_CONVERT_NONE);
287 DECLARE_VA_CTOR(Float,                  float,                  VTX_COMP_FLOAT,                         VTX_COMP_CONVERT_NONE);
288
289 #undef DECLARE_VA_CTOR
290
291 } // va
292
293 } // glu
294
295 #endif // _GLUDRAWUTIL_HPP