Merge "Fix color change verification in dithering tests" into nougat-cts-dev am:...
[platform/upstream/VK-GL-CTS.git] / modules / gles3 / performance / es3pTextureCases.cpp
1 /*-------------------------------------------------------------------------
2  * drawElements Quality Program OpenGL ES 3.0 Module
3  * -------------------------------------------------
4  *
5  * Copyright 2014 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief Texture format performance tests.
22  *//*--------------------------------------------------------------------*/
23
24 #include "es3pTextureCases.hpp"
25 #include "glsShaderPerformanceCase.hpp"
26 #include "tcuTextureUtil.hpp"
27 #include "tcuRenderTarget.hpp"
28 #include "gluTexture.hpp"
29 #include "gluTextureUtil.hpp"
30 #include "gluStrUtil.hpp"
31
32 #include "deStringUtil.hpp"
33
34 #include "glwEnums.hpp"
35 #include "glwFunctions.hpp"
36
37 namespace deqp
38 {
39 namespace gles3
40 {
41 namespace Performance
42 {
43
44 using namespace gls;
45 using namespace glw; // GL types
46 using tcu::Vec2;
47 using tcu::Vec3;
48 using tcu::Vec4;
49 using tcu::IVec4;
50 using std::string;
51 using std::vector;
52 using tcu::TestLog;
53
54 Texture2DRenderCase::Texture2DRenderCase (Context&                      context,
55                                                                                   const char*           name,
56                                                                                   const char*           description,
57                                                                                   deUint32                      internalFormat,
58                                                                                   deUint32                      wrapS,
59                                                                                   deUint32                      wrapT,
60                                                                                   deUint32                      minFilter,
61                                                                                   deUint32                      magFilter,
62                                                                                   const tcu::Mat3&      coordTransform,
63                                                                                   int                           numTextures,
64                                                                                   bool                          powerOfTwo)
65         : ShaderPerformanceCase (context.getTestContext(), context.getRenderContext(), name, description, CASETYPE_FRAGMENT)
66         , m_internalFormat              (internalFormat)
67         , m_wrapS                               (wrapS)
68         , m_wrapT                               (wrapT)
69         , m_minFilter                   (minFilter)
70         , m_magFilter                   (magFilter)
71         , m_coordTransform              (coordTransform)
72         , m_numTextures                 (numTextures)
73         , m_powerOfTwo                  (powerOfTwo)
74 {
75 }
76
77 Texture2DRenderCase::~Texture2DRenderCase (void)
78 {
79         for (vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
80                 delete *i;
81         m_textures.clear();
82 }
83
84 static inline int roundDownToPowerOfTwo (int val)
85 {
86         DE_ASSERT(val >= 0);
87         int l0 = deClz32(val);
88         return val & ~((1<<(31-l0))-1);
89 }
90
91 void Texture2DRenderCase::init (void)
92 {
93         TestLog& log = m_testCtx.getLog();
94
95         const tcu::TextureFormat                texFormat       = glu::mapGLInternalFormat(m_internalFormat);
96         const tcu::TextureFormatInfo    fmtInfo         = tcu::getTextureFormatInfo(texFormat);
97         const glu::Precision                    samplerPrec     = (texFormat.type == tcu::TextureFormat::FLOAT                  ||
98                                                                                                    texFormat.type == tcu::TextureFormat::UNSIGNED_INT32 ||
99                                                                                                    texFormat.type == tcu::TextureFormat::SIGNED_INT32)
100                                                                                                 ? glu::PRECISION_HIGHP : glu::PRECISION_MEDIUMP;
101         const glu::DataType                             samplerType     = glu::getSampler2DType(texFormat);
102         const bool                                              isIntUint       = samplerType == glu::TYPE_INT_SAMPLER_2D || samplerType == glu::TYPE_UINT_SAMPLER_2D;
103
104         int                                                             width           = m_renderCtx.getRenderTarget().getWidth();
105         int                                                             height          = m_renderCtx.getRenderTarget().getHeight();
106
107         if (m_powerOfTwo)
108         {
109                 width   = roundDownToPowerOfTwo(width);
110                 height  = roundDownToPowerOfTwo(height);
111         }
112
113         bool mipmaps = m_minFilter == GL_NEAREST_MIPMAP_NEAREST ||
114                                    m_minFilter == GL_NEAREST_MIPMAP_LINEAR      ||
115                                    m_minFilter == GL_LINEAR_MIPMAP_NEAREST      ||
116                                    m_minFilter == GL_LINEAR_MIPMAP_LINEAR;
117
118         DE_ASSERT(m_powerOfTwo || (!mipmaps && m_wrapS == GL_CLAMP_TO_EDGE && m_wrapT == GL_CLAMP_TO_EDGE));
119
120         Vec2 p00 = (m_coordTransform * Vec3(0.0f, 0.0f, 1.0f)).swizzle(0,1);
121         Vec2 p10 = (m_coordTransform * Vec3(1.0f, 0.0f, 1.0f)).swizzle(0,1);
122         Vec2 p01 = (m_coordTransform * Vec3(0.0f, 1.0f, 1.0f)).swizzle(0,1);
123         Vec2 p11 = (m_coordTransform * Vec3(1.0f, 1.0f, 1.0f)).swizzle(0,1);
124
125         m_attributes.push_back(AttribSpec("a_coords", Vec4(p00.x(), p00.y(), 0.0f, 0.0f),
126                                                                                                   Vec4(p10.x(), p10.y(), 0.0f, 0.0f),
127                                                                                                   Vec4(p01.x(), p01.y(), 0.0f, 0.0f),
128                                                                                                   Vec4(p11.x(), p11.y(), 0.0f, 0.0f)));
129
130         log << TestLog::Message << "Size: " << width << "x" << height << TestLog::EndMessage;
131         log << TestLog::Message << "Format: " <<glu::getTextureFormatName(m_internalFormat) << TestLog::EndMessage;
132         log << TestLog::Message << "Coords: " << p00 << ", " << p10 << ", " << p01 << ", " << p11 << TestLog::EndMessage;
133         log << TestLog::Message << "Wrap: " << glu::getTextureWrapModeStr(m_wrapS) << " / " << glu::getTextureWrapModeStr(m_wrapT) << TestLog::EndMessage;
134         log << TestLog::Message << "Filter: " << glu::getTextureFilterStr(m_minFilter) << " / " << glu::getTextureFilterStr(m_magFilter) << TestLog::EndMessage;
135         log << TestLog::Message << "Mipmaps: " << (mipmaps ? "true" : "false") << TestLog::EndMessage;
136         log << TestLog::Message << "Using additive blending." << TestLog::EndMessage;
137
138         // Use same viewport size as texture size.
139         setViewportSize(width, height);
140
141         m_vertShaderSource =
142                 "#version 300 es\n"
143                 "in highp vec4 a_position;\n"
144                 "in mediump vec2 a_coords;\n"
145                 "out mediump vec2 v_coords;\n"
146                 "void main (void)\n"
147                 "{\n"
148                 "       gl_Position = a_position;\n"
149                 "       v_coords = a_coords;\n"
150                 "}\n";
151
152         std::ostringstream fragSrc;
153         fragSrc << "#version 300 es\n";
154         fragSrc << "layout(location = 0) out mediump vec4 o_color;\n";
155         fragSrc << "in mediump vec2 v_coords;\n";
156
157         for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
158                 fragSrc << "uniform " << glu::getPrecisionName(samplerPrec) << " " << glu::getDataTypeName(samplerType) << " u_sampler" << texNdx << ";\n";
159
160         fragSrc << "void main (void)\n"
161                         << "{\n";
162
163         for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
164         {
165                 if (texNdx == 0)
166                         fragSrc << "\t" << glu::getPrecisionName(samplerPrec) << " vec4 r = ";
167                 else
168                         fragSrc << "\tr += ";
169
170                 if (isIntUint)
171                         fragSrc << "vec4(";
172
173                 fragSrc << "texture(u_sampler" << texNdx << ", v_coords)";
174
175                 if (isIntUint)
176                         fragSrc << ")";
177
178                 fragSrc << ";\n";
179         }
180
181         fragSrc << "    o_color = r;\n"
182                         << "}\n";
183
184         m_fragShaderSource = fragSrc.str();
185
186         m_textures.reserve(m_numTextures);
187         for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
188         {
189                 static const IVec4 swizzles[] = { IVec4(0,1,2,3), IVec4(1,2,3,0), IVec4(2,3,0,1), IVec4(3,0,1,2),
190                                                                                   IVec4(3,2,1,0), IVec4(2,1,0,3), IVec4(1,0,3,2), IVec4(0,3,2,1) };
191                 const IVec4& sw = swizzles[texNdx % DE_LENGTH_OF_ARRAY(swizzles)];
192
193                 glu::Texture2D* texture = new glu::Texture2D(m_renderCtx, m_internalFormat, width, height);
194                 m_textures.push_back(texture);
195
196                 // Fill levels.
197                 int numLevels = mipmaps ? texture->getRefTexture().getNumLevels() : 1;
198                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
199                 {
200                         // \todo [2013-06-02 pyry] Values are not scaled back to 0..1 range in shaders.
201                         texture->getRefTexture().allocLevel(levelNdx);
202                         tcu::fillWithComponentGradients(texture->getRefTexture().getLevel(levelNdx),
203                                                                                         fmtInfo.valueMin.swizzle(sw[0], sw[1], sw[2], sw[3]),
204                                                                                         fmtInfo.valueMax.swizzle(sw[0], sw[1], sw[2], sw[3]));
205                 }
206
207                 texture->upload();
208         }
209
210         ShaderPerformanceCase::init();
211 }
212
213 void Texture2DRenderCase::deinit (void)
214 {
215         for (vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
216                 delete *i;
217         m_textures.clear();
218
219         ShaderPerformanceCase::deinit();
220 }
221
222 void Texture2DRenderCase::setupProgram (deUint32 program)
223 {
224         const glw::Functions& gl = m_renderCtx.getFunctions();
225         for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
226         {
227                 int samplerLoc = gl.getUniformLocation(program, (string("u_sampler") + de::toString(texNdx)).c_str());
228                 gl.uniform1i(samplerLoc, texNdx);
229         }
230 }
231
232 void Texture2DRenderCase::setupRenderState (void)
233 {
234         const glw::Functions& gl = m_renderCtx.getFunctions();
235
236         // Setup additive blending.
237         gl.enable(GL_BLEND);
238         gl.blendFunc(GL_ONE, GL_ONE);
239         gl.blendEquation(GL_FUNC_ADD);
240
241         // Setup textures.
242         for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
243         {
244                 gl.activeTexture(GL_TEXTURE0 + texNdx);
245                 gl.bindTexture(GL_TEXTURE_2D, m_textures[texNdx]->getGLTexture());
246                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,  m_minFilter);
247                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,  m_magFilter);
248                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,              m_wrapS);
249                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,              m_wrapT);
250         }
251 }
252
253
254 } // Performance
255 } // gles3
256 } // deqp