Merge "Remove user-defined dtor and operator=() from tcu::Vector."
[platform/upstream/VK-GL-CTS.git] / framework / referencerenderer / rrPrimitiveAssembler.hpp
1 #ifndef _RRPRIMITIVEASSEMBLER_HPP
2 #define _RRPRIMITIVEASSEMBLER_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Reference Renderer
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 Primitive assembler
24  *//*--------------------------------------------------------------------*/
25
26 #include "rrDefs.hpp"
27 #include "rrVertexPacket.hpp"
28
29 namespace rr
30 {
31 namespace pa
32 {
33
34 struct Triangle
35 {
36         enum
37         {
38                 NUM_VERTICES = 3
39         };
40
41         Triangle (void)
42                 : v0                            (DE_NULL)
43                 , v1                            (DE_NULL)
44                 , v2                            (DE_NULL)
45                 , provokingIndex        (-1)
46         {
47         }
48
49         Triangle (VertexPacket* v0_, VertexPacket* v1_, VertexPacket* v2_, int provokingIndex_)
50                 : v0                            (v0_)
51                 , v1                            (v1_)
52                 , v2                            (v2_)
53                 , provokingIndex        (provokingIndex_)
54         {
55         }
56
57         VertexPacket* getProvokingVertex (void)
58         {
59                 switch (provokingIndex)
60                 {
61                         case 0: return v0;
62                         case 1: return v1;
63                         case 2: return v2;
64                         default:
65                                 DE_ASSERT(false);
66                                 return DE_NULL;
67                 }
68         }
69
70         VertexPacket*   v0;
71         VertexPacket*   v1;
72         VertexPacket*   v2;
73
74         int                             provokingIndex;
75 } DE_WARN_UNUSED_TYPE;
76
77 struct Triangles
78 {
79         template <typename Iterator>
80         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
81         {
82                 const int provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (2);
83
84                 for (size_t ndx = 0; ndx + 2 < numVertices; ndx += 3)
85                         *(outputIterator++) = Triangle(vertices[ndx], vertices[ndx+1], vertices[ndx+2], provokingOffset);
86         }
87
88         static size_t getPrimitiveCount (size_t vertices)
89         {
90                 return vertices / 3;
91         }
92 } DE_WARN_UNUSED_TYPE;
93
94 struct TriangleStrip
95 {
96         template <typename Iterator>
97         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
98         {
99                 if (numVertices < 3)
100                 {
101                 }
102                 else
103                 {
104                         VertexPacket* vert0 = vertices[0];
105                         VertexPacket* vert1 = vertices[1];
106                         size_t ndx = 2;
107
108                         for (;;)
109                         {
110                                 {
111                                         if (ndx >= numVertices)
112                                                 break;
113
114                                         *(outputIterator++) = Triangle(vert0, vert1, vertices[ndx], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (2));
115                                         vert0 = vertices[ndx];
116
117                                         ndx++;
118                                 }
119
120                                 {
121                                         if (ndx >= numVertices)
122                                                 break;
123
124                                         *(outputIterator++) = Triangle(vert0, vert1, vertices[ndx], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (1) : (2));
125                                         vert1 = vertices[ndx];
126
127                                         ndx++;
128                                 }
129                         }
130                 }
131         }
132
133         static size_t getPrimitiveCount (size_t vertices)
134         {
135                 return (vertices < 3) ? (0) : (vertices - 2);
136         }
137 } DE_WARN_UNUSED_TYPE;
138
139 struct TriangleFan
140 {
141         template <typename Iterator>
142         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
143         {
144                 if (numVertices == 0)
145                 {
146                 }
147                 else
148                 {
149                         const int                       provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (1) : (2);
150                         VertexPacket* const     first                   = vertices[0];
151
152                         for (size_t ndx = 1; ndx + 1 < numVertices; ++ndx)
153                                 *(outputIterator++) = Triangle(first, vertices[ndx], vertices[ndx+1], provokingOffset);
154                 }
155         }
156
157         static size_t getPrimitiveCount (size_t vertices)
158         {
159                 return (vertices < 3) ? (0) : (vertices - 2);
160         }
161 } DE_WARN_UNUSED_TYPE;
162
163 struct Line
164 {
165         enum
166         {
167                 NUM_VERTICES = 2
168         };
169
170         Line (void)
171                 : v0                            (DE_NULL)
172                 , v1                            (DE_NULL)
173                 , provokingIndex        (-1)
174         {
175         }
176
177         Line (VertexPacket* v0_, VertexPacket* v1_, int provokingIndex_)
178                 : v0                            (v0_)
179                 , v1                            (v1_)
180                 , provokingIndex        (provokingIndex_)
181         {
182         }
183
184         VertexPacket* getProvokingVertex (void)
185         {
186                 switch (provokingIndex)
187                 {
188                         case 0: return v0;
189                         case 1: return v1;
190                         default:
191                                 DE_ASSERT(false);
192                                 return DE_NULL;
193                 }
194         }
195
196         VertexPacket*   v0;
197         VertexPacket*   v1;
198
199         int                             provokingIndex;
200 } DE_WARN_UNUSED_TYPE;
201
202 struct Lines
203 {
204         template <typename Iterator>
205         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
206         {
207                 const int provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (1);
208
209                 for (size_t ndx = 0; ndx + 1 < numVertices; ndx += 2)
210                         *(outputIterator++) = Line(vertices[ndx], vertices[ndx+1], provokingOffset);
211         }
212
213         static size_t getPrimitiveCount (size_t vertices)
214         {
215                 return vertices / 2;
216         }
217 } DE_WARN_UNUSED_TYPE;
218
219 struct LineStrip
220 {
221         template <typename Iterator>
222         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
223         {
224                 if (numVertices == 0)
225                 {
226                 }
227                 else
228                 {
229                         VertexPacket* prev = vertices[0];
230
231                         for (size_t ndx = 1; ndx < numVertices; ++ndx)
232                         {
233                                 *(outputIterator++) = Line(prev, vertices[ndx], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (1));
234                                 prev = vertices[ndx];
235                         }
236                 }
237         }
238
239         static size_t getPrimitiveCount (size_t vertices)
240         {
241                 return (vertices < 2) ? (0) : (vertices - 1);
242         }
243 } DE_WARN_UNUSED_TYPE;
244
245 struct LineLoop
246 {
247         template <typename Iterator>
248         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
249         {
250                 if (numVertices < 2)
251                 {
252                 }
253                 else
254                 {
255                         VertexPacket* prev = vertices[0];
256
257                         for (size_t ndx = 1; ndx < numVertices; ++ndx)
258                         {
259                                 *(outputIterator++) = Line(prev, vertices[ndx], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (1));
260                                 prev = vertices[ndx];
261                         }
262
263                         *(outputIterator++) = Line(prev, vertices[0], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (1));
264                 }
265         }
266
267         static size_t getPrimitiveCount (size_t vertices)
268         {
269                 return (vertices < 2) ? (0) : (vertices);
270         }
271 } DE_WARN_UNUSED_TYPE;
272
273 struct Point
274 {
275         enum
276         {
277                 NUM_VERTICES = 1
278         };
279
280         Point (void)
281                 : v0(DE_NULL)
282         {
283         }
284
285         Point (VertexPacket* v0_)
286                 : v0(v0_)
287         {
288         }
289
290         VertexPacket* v0;
291 } DE_WARN_UNUSED_TYPE;
292
293 struct Points
294 {
295         template <typename Iterator>
296         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
297         {
298                 DE_UNREF(provokingConvention);
299
300                 for (size_t ndx = 0; ndx < numVertices; ++ndx)
301                         *(outputIterator++) = Point(vertices[ndx]);
302         }
303
304         static size_t getPrimitiveCount (size_t vertices)
305         {
306                 return (vertices);
307         }
308 } DE_WARN_UNUSED_TYPE;
309
310 struct LineAdjacency
311 {
312         enum
313         {
314                 NUM_VERTICES = 4
315         };
316
317         LineAdjacency (void)
318                 : v0                            (DE_NULL)
319                 , v1                            (DE_NULL)
320                 , v2                            (DE_NULL)
321                 , v3                            (DE_NULL)
322                 , provokingIndex        (-1)
323         {
324         }
325
326         LineAdjacency (VertexPacket* v0_, VertexPacket* v1_, VertexPacket* v2_, VertexPacket* v3_, int provokingIndex_)
327                 : v0                            (v0_)
328                 , v1                            (v1_)
329                 , v2                            (v2_)
330                 , v3                            (v3_)
331                 , provokingIndex        (provokingIndex_)
332         {
333         }
334
335         VertexPacket* getProvokingVertex (void)
336         {
337                 switch (provokingIndex)
338                 {
339                         case 1: return v1;
340                         case 2: return v2;
341                         default:
342                                 DE_ASSERT(false);
343                                 return DE_NULL;
344                 }
345         }
346
347         VertexPacket*   v0;
348         VertexPacket*   v1;
349         VertexPacket*   v2;
350         VertexPacket*   v3;
351
352         int                             provokingIndex;
353 } DE_WARN_UNUSED_TYPE;
354
355 struct LinesAdjacency
356 {
357         template <typename Iterator>
358         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
359         {
360                 const int provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (1) : (2);
361
362                 for (size_t ndx = 0; ndx + 3 < numVertices; ndx += 4)
363                         *(outputIterator++) = LineAdjacency(vertices[ndx], vertices[ndx+1], vertices[ndx+2], vertices[ndx+3], provokingOffset);
364         }
365
366         static size_t getPrimitiveCount (size_t vertices)
367         {
368                 return vertices / 4;
369         }
370 } DE_WARN_UNUSED_TYPE;
371
372 struct LineStripAdjacency
373 {
374         template <typename Iterator>
375         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
376         {
377                 const int provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (1) : (2);
378
379                 for (size_t ndx = 0; ndx + 3 < numVertices; ++ndx)
380                         *(outputIterator++) = LineAdjacency(vertices[ndx], vertices[ndx+1], vertices[ndx+2], vertices[ndx+3], provokingOffset);
381         }
382
383         static size_t getPrimitiveCount (size_t vertices)
384         {
385                 return (vertices < 4) ? (0) : (vertices - 3);
386         }
387 } DE_WARN_UNUSED_TYPE;
388
389 struct TriangleAdjacency
390 {
391         enum
392         {
393                 NUM_VERTICES = 6
394         };
395
396         TriangleAdjacency (void)
397                 : v0                            (DE_NULL)
398                 , v1                            (DE_NULL)
399                 , v2                            (DE_NULL)
400                 , v3                            (DE_NULL)
401                 , v4                            (DE_NULL)
402                 , v5                            (DE_NULL)
403                 , provokingIndex        (-1)
404         {
405         }
406
407         TriangleAdjacency (VertexPacket* v0_, VertexPacket* v1_, VertexPacket* v2_, VertexPacket* v3_, VertexPacket* v4_, VertexPacket* v5_, int provokingIndex_)
408                 : v0                            (v0_)
409                 , v1                            (v1_)
410                 , v2                            (v2_)
411                 , v3                            (v3_)
412                 , v4                            (v4_)
413                 , v5                            (v5_)
414                 , provokingIndex        (provokingIndex_)
415         {
416         }
417
418         VertexPacket* getProvokingVertex (void)
419         {
420                 switch (provokingIndex)
421                 {
422                         case 0: return v0;
423                         case 2: return v2;
424                         case 4: return v4;
425                         default:
426                                 DE_ASSERT(false);
427                                 return DE_NULL;
428                 }
429         }
430
431         VertexPacket*   v0;
432         VertexPacket*   v1;     //!< adjacent
433         VertexPacket*   v2;
434         VertexPacket*   v3;     //!< adjacent
435         VertexPacket*   v4;
436         VertexPacket*   v5;     //!< adjacent
437
438         int                             provokingIndex;
439 } DE_WARN_UNUSED_TYPE;
440
441 struct TrianglesAdjacency
442 {
443         template <typename Iterator>
444         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
445         {
446                 const int provokingOffset = (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (4);
447
448                 for (size_t ndx = 0; ndx + 5 < numVertices; ndx += 6)
449                         *(outputIterator++) = TriangleAdjacency(vertices[ndx], vertices[ndx+1], vertices[ndx+2], vertices[ndx+3], vertices[ndx+4], vertices[ndx+5], provokingOffset);
450         }
451
452         static size_t getPrimitiveCount (size_t vertices)
453         {
454                 return vertices / 6;
455         }
456 } DE_WARN_UNUSED_TYPE;
457
458 struct TriangleStripAdjacency
459 {
460         template <typename Iterator>
461         static void exec (Iterator outputIterator, VertexPacket* const* vertices, size_t numVertices, rr::ProvokingVertex provokingConvention)
462         {
463                 if (numVertices < 6)
464                 {
465                 }
466                 else if (numVertices < 8)
467                 {
468                         *(outputIterator++) = TriangleAdjacency(vertices[0], vertices[1], vertices[2], vertices[5], vertices[4], vertices[3], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (4));
469                 }
470                 else
471                 {
472                         const size_t primitiveCount = getPrimitiveCount(numVertices);
473                         size_t i;
474
475                         // first
476                         *(outputIterator++) = TriangleAdjacency(vertices[0], vertices[1], vertices[2], vertices[6], vertices[4], vertices[3], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (4));
477
478                         // middle
479                         for (i = 1; i + 1 < primitiveCount; ++i)
480                         {
481                                 // odd
482                                 if (i % 2 == 1)
483                                 {
484                                         *(outputIterator++) = TriangleAdjacency(vertices[2*i+2], vertices[2*i-2], vertices[2*i+0], vertices[2*i+3], vertices[2*i+4], vertices[2*i+6], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (2) : (4));
485                                 }
486                                 // even
487                                 else
488                                 {
489                                         *(outputIterator++) = TriangleAdjacency(vertices[2*i+0], vertices[2*i-2], vertices[2*i+2], vertices[2*i+6], vertices[2*i+4], vertices[2*i+3], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (4));
490                                 }
491                         }
492
493                         // last
494
495                         // odd
496                         if (i % 2 == 1)
497                                 *(outputIterator++) = TriangleAdjacency(vertices[2*i+2], vertices[2*i-2], vertices[2*i+0], vertices[2*i+3], vertices[2*i+4], vertices[2*i+5], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (2) : (4));
498                         // even
499                         else
500                                 *(outputIterator++) = TriangleAdjacency(vertices[2*i+0], vertices[2*i-2], vertices[2*i+2], vertices[2*i+5], vertices[2*i+4], vertices[2*i+3], (provokingConvention == rr::PROVOKINGVERTEX_FIRST) ? (0) : (4));
501                 }
502         }
503
504         static size_t getPrimitiveCount (size_t vertices)
505         {
506                 return (vertices < 6) ? 0 : ((vertices - 4) / 2);
507         }
508 } DE_WARN_UNUSED_TYPE;
509
510 } // pa
511 } // rr
512
513 #endif // _RRPRIMITIVEASSEMBLER_HPP