lin
2025-08-14 dae8bad597b6607a449b32bf76c523423f7720ed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#ifndef _GLSSTATECHANGEPERFTESTCASES_HPP
#define _GLSSTATECHANGEPERFTESTCASES_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief State change performance tests.
 *//*--------------------------------------------------------------------*/
 
#include "tcuDefs.hpp"
#include "tcuTestCase.hpp"
 
namespace glu
{
class ShaderProgram;
class RenderContext;
}
 
namespace glw
{
class Functions;
}
 
namespace deqp
{
namespace gls
{
 
class StateChangePerformanceCase : public tcu::TestCase
{
public:
   enum DrawType
   {
       DRAWTYPE_NOT_INDEXED        = 0,    //!< glDrawArrays()
       DRAWTYPE_INDEXED_USER_PTR,            //!< glDrawElements(), indices from user pointer.
       DRAWTYPE_INDEXED_BUFFER,            //!< glDrawElements(), indices in buffer.
   };
 
                                       StateChangePerformanceCase        (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, DrawType drawType, int drawCallCount, int triangleCount);
                                       ~StateChangePerformanceCase        (void);
 
   void                                init                            (void);
   void                                deinit                            (void);
 
   IterateResult                        iterate                            (void);
 
protected:
   void                                requireIndexBuffers                (int count);
   void                                requireCoordBuffers                (int count);
   void                                requirePrograms                    (int count);
   void                                requireTextures                    (int count);
   void                                requireFramebuffers                (int count);
   void                                requireRenderbuffers            (int count);
   void                                requireSamplers                    (int count);
   void                                requireVertexArrays                (int count);
 
   virtual void                        setupInitialState                (const glw::Functions& gl) = 0;
   virtual void                        renderTest                        (const glw::Functions& gl) = 0;
   virtual void                        renderReference                    (const glw::Functions& gl) = 0;
 
   void                                callDraw                        (const glw::Functions& gl);
 
   void                                logAndSetTestResult                (void);
 
protected:
   glu::RenderContext&                    m_renderCtx;
 
   const DrawType                        m_drawType;
   const int                            m_iterationCount;
   const int                            m_callCount;
   const int                            m_triangleCount;
 
   std::vector<deUint32>                m_indexBuffers;
   std::vector<deUint32>                m_coordBuffers;
   std::vector<deUint32>                m_textures;
   std::vector<glu::ShaderProgram*>    m_programs;
   std::vector<deUint32>                m_framebuffers;
   std::vector<deUint32>                m_renderbuffers;
   std::vector<deUint32>                m_samplers;
   std::vector<deUint32>                m_vertexArrays;
 
private:
                                       StateChangePerformanceCase        (const StateChangePerformanceCase&);
   StateChangePerformanceCase&            operator=                        (const StateChangePerformanceCase&);
 
   std::vector<deUint16>                m_indices;
 
   std::vector<deUint64>                m_interleavedResults;
   std::vector<deUint64>                m_batchedResults;
};
 
class StateChangeCallPerformanceCase : public tcu::TestCase
{
public:
 
                           StateChangeCallPerformanceCase    (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description);
                           ~StateChangeCallPerformanceCase    (void);
 
   IterateResult            iterate                            (void);
 
   virtual void            execCalls                        (const glw::Functions& gl, int iterNdx, int callCount) = 0;
 
private:
   void                    executeTest                        (void);
   void                    logTestCase                        (void);
 
   void                    logAndSetTestResult                (void);
 
   glu::RenderContext&        m_renderCtx;
 
   const int                m_iterationCount;
   const int                m_callCount;
 
   std::vector<deUint64>    m_results;
};
 
} // gls
} // deqp
 
#endif // _GLSSTATECHANGEPERFTESTCASES_HPP