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
Texture2DRenderCase(Context & context,const char * name,const char * description,deUint32 internalFormat,deUint32 wrapS,deUint32 wrapT,deUint32 minFilter,deUint32 magFilter,const tcu::Mat3 & coordTransform,int numTextures,bool powerOfTwo)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
~Texture2DRenderCase(void)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
roundDownToPowerOfTwo(int val)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
init(void)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
deinit(void)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
setupProgram(deUint32 program)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
setupRenderState(void)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
257