1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL (ES) 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 Shader execute test.
22 *
23 * \todo [petri] Multiple grid with differing constants/uniforms.
24 * \todo [petri]
25 *//*--------------------------------------------------------------------*/
26
27 #include "glsShaderRenderCase.hpp"
28
29 #include "tcuSurface.hpp"
30 #include "tcuVector.hpp"
31 #include "tcuImageCompare.hpp"
32 #include "tcuTestLog.hpp"
33 #include "tcuRenderTarget.hpp"
34
35 #include "gluPixelTransfer.hpp"
36 #include "gluTexture.hpp"
37 #include "gluTextureUtil.hpp"
38 #include "gluDrawUtil.hpp"
39
40 #include "glwFunctions.hpp"
41 #include "glwEnums.hpp"
42
43 #include "deRandom.hpp"
44 #include "deMemory.h"
45 #include "deString.h"
46 #include "deMath.h"
47 #include "deStringUtil.hpp"
48
49 #include <stdio.h>
50 #include <vector>
51 #include <string>
52
53 namespace deqp
54 {
55 namespace gls
56 {
57
58 using namespace std;
59 using namespace tcu;
60 using namespace glu;
61
62 static const int GRID_SIZE = 64;
63 static const int MAX_RENDER_WIDTH = 128;
64 static const int MAX_RENDER_HEIGHT = 112;
65 static const tcu::Vec4 DEFAULT_CLEAR_COLOR = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f);
66
toRGBA(const Vec4 & a)67 inline RGBA toRGBA (const Vec4& a)
68 {
69 return RGBA(deClamp32(deRoundFloatToInt32(a.x() * 255.0f), 0, 255),
70 deClamp32(deRoundFloatToInt32(a.y() * 255.0f), 0, 255),
71 deClamp32(deRoundFloatToInt32(a.z() * 255.0f), 0, 255),
72 deClamp32(deRoundFloatToInt32(a.w() * 255.0f), 0, 255));
73 }
74
toVec(const RGBA & c)75 inline tcu::Vec4 toVec (const RGBA& c)
76 {
77 return tcu::Vec4(c.getRed() / 255.0f,
78 c.getGreen() / 255.0f,
79 c.getBlue() / 255.0f,
80 c.getAlpha() / 255.0f);
81 }
82
83 // TextureBinding
84
TextureBinding(const glu::Texture2D * tex2D,const tcu::Sampler & sampler)85 TextureBinding::TextureBinding (const glu::Texture2D* tex2D, const tcu::Sampler& sampler)
86 : m_type (TYPE_2D)
87 , m_sampler (sampler)
88 {
89 m_binding.tex2D = tex2D;
90 }
91
TextureBinding(const glu::TextureCube * texCube,const tcu::Sampler & sampler)92 TextureBinding::TextureBinding (const glu::TextureCube* texCube, const tcu::Sampler& sampler)
93 : m_type (TYPE_CUBE_MAP)
94 , m_sampler (sampler)
95 {
96 m_binding.texCube = texCube;
97 }
98
TextureBinding(const glu::Texture2DArray * tex2DArray,const tcu::Sampler & sampler)99 TextureBinding::TextureBinding (const glu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler)
100 : m_type (TYPE_2D_ARRAY)
101 , m_sampler (sampler)
102 {
103 m_binding.tex2DArray = tex2DArray;
104 }
105
TextureBinding(const glu::Texture3D * tex3D,const tcu::Sampler & sampler)106 TextureBinding::TextureBinding (const glu::Texture3D* tex3D, const tcu::Sampler& sampler)
107 : m_type (TYPE_3D)
108 , m_sampler (sampler)
109 {
110 m_binding.tex3D = tex3D;
111 }
112
TextureBinding(void)113 TextureBinding::TextureBinding (void)
114 : m_type (TYPE_NONE)
115 {
116 m_binding.tex2D = DE_NULL;
117 }
118
setSampler(const tcu::Sampler & sampler)119 void TextureBinding::setSampler (const tcu::Sampler& sampler)
120 {
121 m_sampler = sampler;
122 }
123
setTexture(const glu::Texture2D * tex2D)124 void TextureBinding::setTexture (const glu::Texture2D* tex2D)
125 {
126 m_type = TYPE_2D;
127 m_binding.tex2D = tex2D;
128 }
129
setTexture(const glu::TextureCube * texCube)130 void TextureBinding::setTexture (const glu::TextureCube* texCube)
131 {
132 m_type = TYPE_CUBE_MAP;
133 m_binding.texCube = texCube;
134 }
135
setTexture(const glu::Texture2DArray * tex2DArray)136 void TextureBinding::setTexture (const glu::Texture2DArray* tex2DArray)
137 {
138 m_type = TYPE_2D_ARRAY;
139 m_binding.tex2DArray = tex2DArray;
140 }
141
setTexture(const glu::Texture3D * tex3D)142 void TextureBinding::setTexture (const glu::Texture3D* tex3D)
143 {
144 m_type = TYPE_3D;
145 m_binding.tex3D = tex3D;
146 }
147
148 // QuadGrid.
149
150 class QuadGrid
151 {
152 public:
153 QuadGrid (int gridSize, int screenWidth, int screenHeight, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures);
154 ~QuadGrid (void);
155
getGridSize(void) const156 int getGridSize (void) const { return m_gridSize; }
getNumVertices(void) const157 int getNumVertices (void) const { return m_numVertices; }
getNumTriangles(void) const158 int getNumTriangles (void) const { return m_numTriangles; }
getConstCoords(void) const159 const Vec4& getConstCoords (void) const { return m_constCoords; }
getUserAttribTransforms(void) const160 const vector<Mat4> getUserAttribTransforms (void) const { return m_userAttribTransforms; }
getTextures(void) const161 const vector<TextureBinding>& getTextures (void) const { return m_textures; }
162
getPositions(void) const163 const Vec4* getPositions (void) const { return &m_positions[0]; }
getAttribOne(void) const164 const float* getAttribOne (void) const { return &m_attribOne[0]; }
getCoords(void) const165 const Vec4* getCoords (void) const { return &m_coords[0]; }
getUnitCoords(void) const166 const Vec4* getUnitCoords (void) const { return &m_unitCoords[0]; }
getUserAttrib(int attribNdx) const167 const Vec4* getUserAttrib (int attribNdx) const { return &m_userAttribs[attribNdx][0]; }
getIndices(void) const168 const deUint16* getIndices (void) const { return &m_indices[0]; }
169
170 Vec4 getCoords (float sx, float sy) const;
171 Vec4 getUnitCoords (float sx, float sy) const;
172
getNumUserAttribs(void) const173 int getNumUserAttribs (void) const { return (int)m_userAttribTransforms.size(); }
174 Vec4 getUserAttrib (int attribNdx, float sx, float sy) const;
175
176 private:
177 int m_gridSize;
178 int m_numVertices;
179 int m_numTriangles;
180 Vec4 m_constCoords;
181 vector<Mat4> m_userAttribTransforms;
182 vector<TextureBinding> m_textures;
183
184 vector<Vec4> m_screenPos;
185 vector<Vec4> m_positions;
186 vector<Vec4> m_coords; //!< Near-unit coordinates, roughly [-2.0 .. 2.0].
187 vector<Vec4> m_unitCoords; //!< Positive-only coordinates [0.0 .. 1.5].
188 vector<float> m_attribOne;
189 vector<Vec4> m_userAttribs[ShaderEvalContext::MAX_TEXTURES];
190 vector<deUint16> m_indices;
191 };
192
QuadGrid(int gridSize,int width,int height,const Vec4 & constCoords,const vector<Mat4> & userAttribTransforms,const vector<TextureBinding> & textures)193 QuadGrid::QuadGrid (int gridSize, int width, int height, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures)
194 : m_gridSize (gridSize)
195 , m_numVertices ((gridSize + 1) * (gridSize + 1))
196 , m_numTriangles (gridSize * gridSize * 2)
197 , m_constCoords (constCoords)
198 , m_userAttribTransforms (userAttribTransforms)
199 , m_textures (textures)
200 {
201 Vec4 viewportScale = Vec4((float)width, (float)height, 0.0f, 0.0f);
202
203 // Compute vertices.
204 m_positions.resize(m_numVertices);
205 m_coords.resize(m_numVertices);
206 m_unitCoords.resize(m_numVertices);
207 m_attribOne.resize(m_numVertices);
208 m_screenPos.resize(m_numVertices);
209
210 // User attributes.
211 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_userAttribs); i++)
212 m_userAttribs[i].resize(m_numVertices);
213
214 for (int y = 0; y < gridSize+1; y++)
215 for (int x = 0; x < gridSize+1; x++)
216 {
217 float sx = x / (float)gridSize;
218 float sy = y / (float)gridSize;
219 float fx = 2.0f * sx - 1.0f;
220 float fy = 2.0f * sy - 1.0f;
221 int vtxNdx = ((y * (gridSize+1)) + x);
222
223 m_positions[vtxNdx] = Vec4(fx, fy, 0.0f, 1.0f);
224 m_attribOne[vtxNdx] = 1.0f;
225 m_screenPos[vtxNdx] = Vec4(sx, sy, 0.0f, 1.0f) * viewportScale;
226 m_coords[vtxNdx] = getCoords(sx, sy);
227 m_unitCoords[vtxNdx] = getUnitCoords(sx, sy);
228
229 for (int attribNdx = 0; attribNdx < getNumUserAttribs(); attribNdx++)
230 m_userAttribs[attribNdx][vtxNdx] = getUserAttrib(attribNdx, sx, sy);
231 }
232
233 // Compute indices.
234 m_indices.resize(3 * m_numTriangles);
235 for (int y = 0; y < gridSize; y++)
236 for (int x = 0; x < gridSize; x++)
237 {
238 int stride = gridSize + 1;
239 int v00 = (y * stride) + x;
240 int v01 = (y * stride) + x + 1;
241 int v10 = ((y+1) * stride) + x;
242 int v11 = ((y+1) * stride) + x + 1;
243
244 int baseNdx = ((y * gridSize) + x) * 6;
245 m_indices[baseNdx + 0] = v10;
246 m_indices[baseNdx + 1] = v00;
247 m_indices[baseNdx + 2] = v01;
248
249 m_indices[baseNdx + 3] = v10;
250 m_indices[baseNdx + 4] = v01;
251 m_indices[baseNdx + 5] = v11;
252 }
253 }
254
~QuadGrid(void)255 QuadGrid::~QuadGrid (void)
256 {
257 }
258
getCoords(float sx,float sy) const259 inline Vec4 QuadGrid::getCoords (float sx, float sy) const
260 {
261 float fx = 2.0f * sx - 1.0f;
262 float fy = 2.0f * sy - 1.0f;
263 return Vec4(fx, fy, -fx + 0.33f*fy, -0.275f*fx - fy);
264 }
265
getUnitCoords(float sx,float sy) const266 inline Vec4 QuadGrid::getUnitCoords (float sx, float sy) const
267 {
268 return Vec4(sx, sy, 0.33f*sx + 0.5f*sy, 0.5f*sx + 0.25f*sy);
269 }
270
getUserAttrib(int attribNdx,float sx,float sy) const271 inline Vec4 QuadGrid::getUserAttrib (int attribNdx, float sx, float sy) const
272 {
273 // homogeneous normalized screen-space coordinates
274 return m_userAttribTransforms[attribNdx] * Vec4(sx, sy, 0.0f, 1.0f);
275 }
276
277 // ShaderEvalContext.
278
ShaderEvalContext(const QuadGrid & quadGrid_)279 ShaderEvalContext::ShaderEvalContext (const QuadGrid& quadGrid_)
280 : constCoords (quadGrid_.getConstCoords())
281 , isDiscarded (false)
282 , quadGrid (quadGrid_)
283 {
284 const vector<TextureBinding>& bindings = quadGrid.getTextures();
285 DE_ASSERT((int)bindings.size() <= MAX_TEXTURES);
286
287 // Fill in texture array.
288 for (int ndx = 0; ndx < (int)bindings.size(); ndx++)
289 {
290 const TextureBinding& binding = bindings[ndx];
291
292 if (binding.getType() == TextureBinding::TYPE_NONE)
293 continue;
294
295 textures[ndx].sampler = binding.getSampler();
296
297 switch (binding.getType())
298 {
299 case TextureBinding::TYPE_2D: textures[ndx].tex2D = &binding.get2D()->getRefTexture(); break;
300 case TextureBinding::TYPE_CUBE_MAP: textures[ndx].texCube = &binding.getCube()->getRefTexture(); break;
301 case TextureBinding::TYPE_2D_ARRAY: textures[ndx].tex2DArray = &binding.get2DArray()->getRefTexture(); break;
302 case TextureBinding::TYPE_3D: textures[ndx].tex3D = &binding.get3D()->getRefTexture(); break;
303 default:
304 DE_ASSERT(DE_FALSE);
305 }
306 }
307 }
308
~ShaderEvalContext(void)309 ShaderEvalContext::~ShaderEvalContext (void)
310 {
311 }
312
reset(float sx,float sy)313 void ShaderEvalContext::reset (float sx, float sy)
314 {
315 // Clear old values
316 color = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
317 isDiscarded = false;
318
319 // Compute coords
320 coords = quadGrid.getCoords(sx, sy);
321 unitCoords = quadGrid.getUnitCoords(sx, sy);
322
323 // Compute user attributes.
324 int numAttribs = quadGrid.getNumUserAttribs();
325 DE_ASSERT(numAttribs <= MAX_USER_ATTRIBS);
326 for (int attribNdx = 0; attribNdx < numAttribs; attribNdx++)
327 in[attribNdx] = quadGrid.getUserAttrib(attribNdx, sx, sy);
328 }
329
texture2D(int unitNdx,const tcu::Vec2 & texCoords)330 tcu::Vec4 ShaderEvalContext::texture2D (int unitNdx, const tcu::Vec2& texCoords)
331 {
332 if (textures[unitNdx].tex2D)
333 return textures[unitNdx].tex2D->sample(textures[unitNdx].sampler, texCoords.x(), texCoords.y(), 0.0f);
334 else
335 return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
336 }
337
338 // ShaderEvaluator
339
ShaderEvaluator(void)340 ShaderEvaluator::ShaderEvaluator (void)
341 : m_evalFunc(DE_NULL)
342 {
343 }
344
ShaderEvaluator(ShaderEvalFunc evalFunc)345 ShaderEvaluator::ShaderEvaluator (ShaderEvalFunc evalFunc)
346 : m_evalFunc(evalFunc)
347 {
348 }
349
~ShaderEvaluator(void)350 ShaderEvaluator::~ShaderEvaluator (void)
351 {
352 }
353
evaluate(ShaderEvalContext & ctx)354 void ShaderEvaluator::evaluate (ShaderEvalContext& ctx)
355 {
356 DE_ASSERT(m_evalFunc);
357 m_evalFunc(ctx);
358 }
359
360 // ShaderRenderCase.
361
ShaderRenderCase(TestContext & testCtx,RenderContext & renderCtx,const ContextInfo & ctxInfo,const char * name,const char * description,bool isVertexCase,ShaderEvalFunc evalFunc)362 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc)
363 : TestCase (testCtx, name, description)
364 , m_renderCtx (renderCtx)
365 , m_ctxInfo (ctxInfo)
366 , m_isVertexCase (isVertexCase)
367 , m_defaultEvaluator (evalFunc)
368 , m_evaluator (m_defaultEvaluator)
369 , m_clearColor (DEFAULT_CLEAR_COLOR)
370 , m_program (DE_NULL)
371 {
372 }
373
ShaderRenderCase(TestContext & testCtx,RenderContext & renderCtx,const ContextInfo & ctxInfo,const char * name,const char * description,bool isVertexCase,ShaderEvaluator & evaluator)374 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvaluator& evaluator)
375 : TestCase (testCtx, name, description)
376 , m_renderCtx (renderCtx)
377 , m_ctxInfo (ctxInfo)
378 , m_isVertexCase (isVertexCase)
379 , m_defaultEvaluator (DE_NULL)
380 , m_evaluator (evaluator)
381 , m_clearColor (DEFAULT_CLEAR_COLOR)
382 , m_program (DE_NULL)
383 {
384 }
385
~ShaderRenderCase(void)386 ShaderRenderCase::~ShaderRenderCase (void)
387 {
388 ShaderRenderCase::deinit();
389 }
390
init(void)391 void ShaderRenderCase::init (void)
392 {
393 TestLog& log = m_testCtx.getLog();
394 const glw::Functions& gl = m_renderCtx.getFunctions();
395
396 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() begin");
397
398 if (m_vertShaderSource.empty() || m_fragShaderSource.empty())
399 {
400 DE_ASSERT(m_vertShaderSource.empty() && m_fragShaderSource.empty());
401 setupShaderData();
402 }
403
404 DE_ASSERT(!m_program);
405 m_program = new ShaderProgram(m_renderCtx, makeVtxFragSources(m_vertShaderSource, m_fragShaderSource));
406
407 try
408 {
409 log << *m_program; // Always log shader program.
410
411 if (!m_program->isOk())
412 throw CompileFailed(__FILE__, __LINE__);
413
414 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() end");
415 }
416 catch (const std::exception&)
417 {
418 // Clean up.
419 ShaderRenderCase::deinit();
420 throw;
421 }
422 }
423
deinit(void)424 void ShaderRenderCase::deinit (void)
425 {
426 delete m_program;
427 m_program = DE_NULL;
428 }
429
getViewportSize(void) const430 tcu::IVec2 ShaderRenderCase::getViewportSize (void) const
431 {
432 return tcu::IVec2(de::min(m_renderCtx.getRenderTarget().getWidth(), MAX_RENDER_WIDTH),
433 de::min(m_renderCtx.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT));
434 }
435
iterate(void)436 TestNode::IterateResult ShaderRenderCase::iterate (void)
437 {
438 const glw::Functions& gl = m_renderCtx.getFunctions();
439
440 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::iterate() begin");
441
442 DE_ASSERT(m_program);
443 deUint32 programID = m_program->getProgram();
444 gl.useProgram(programID);
445
446 // Create quad grid.
447 IVec2 viewportSize = getViewportSize();
448 int width = viewportSize.x();
449 int height = viewportSize.y();
450
451 // \todo [petri] Better handling of constCoords (render in multiple chunks, vary coords).
452 QuadGrid quadGrid(m_isVertexCase ? GRID_SIZE : 4, width, height, Vec4(0.125f, 0.25f, 0.5f, 1.0f), m_userAttribTransforms, m_textures);
453
454 // Render result.
455 Surface resImage(width, height);
456 render(resImage, programID, quadGrid);
457
458 // Compute reference.
459 Surface refImage (width, height);
460 if (m_isVertexCase)
461 computeVertexReference(refImage, quadGrid);
462 else
463 computeFragmentReference(refImage, quadGrid);
464
465 // Compare.
466 bool testOk = compareImages(resImage, refImage, 0.05f);
467
468 // De-initialize.
469 gl.useProgram(0);
470
471 m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
472 testOk ? "Pass" : "Fail");
473 return TestNode::STOP;
474 }
475
setupShaderData(void)476 void ShaderRenderCase::setupShaderData (void)
477 {
478 }
479
setup(int programID)480 void ShaderRenderCase::setup (int programID)
481 {
482 DE_UNREF(programID);
483 }
484
setupUniforms(int programID,const Vec4 & constCoords)485 void ShaderRenderCase::setupUniforms (int programID, const Vec4& constCoords)
486 {
487 DE_UNREF(programID);
488 DE_UNREF(constCoords);
489 }
490
setupDefaultInputs(int programID)491 void ShaderRenderCase::setupDefaultInputs (int programID)
492 {
493 const glw::Functions& gl = m_renderCtx.getFunctions();
494
495 // SETUP UNIFORMS.
496
497 setupDefaultUniforms(m_renderCtx, programID);
498
499 GLU_EXPECT_NO_ERROR(gl.getError(), "post uniform setup");
500
501 // SETUP TEXTURES.
502
503 for (int ndx = 0; ndx < (int)m_textures.size(); ndx++)
504 {
505 const TextureBinding& tex = m_textures[ndx];
506 const tcu::Sampler& sampler = tex.getSampler();
507 deUint32 texTarget = GL_NONE;
508 deUint32 texObj = 0;
509
510 if (tex.getType() == TextureBinding::TYPE_NONE)
511 continue;
512
513 // Feature check.
514 if (m_renderCtx.getType().getAPI() == glu::ApiType::es(2,0))
515 {
516 if (tex.getType() == TextureBinding::TYPE_2D_ARRAY)
517 throw tcu::NotSupportedError("2D array texture binding is not supported");
518
519 if (tex.getType() == TextureBinding::TYPE_3D)
520 throw tcu::NotSupportedError("3D texture binding is not supported");
521
522 if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE)
523 throw tcu::NotSupportedError("Shadow lookups are not supported");
524 }
525
526 switch (tex.getType())
527 {
528 case TextureBinding::TYPE_2D: texTarget = GL_TEXTURE_2D; texObj = tex.get2D()->getGLTexture(); break;
529 case TextureBinding::TYPE_CUBE_MAP: texTarget = GL_TEXTURE_CUBE_MAP; texObj = tex.getCube()->getGLTexture(); break;
530 case TextureBinding::TYPE_2D_ARRAY: texTarget = GL_TEXTURE_2D_ARRAY; texObj = tex.get2DArray()->getGLTexture(); break;
531 case TextureBinding::TYPE_3D: texTarget = GL_TEXTURE_3D; texObj = tex.get3D()->getGLTexture(); break;
532 default:
533 DE_ASSERT(DE_FALSE);
534 }
535
536 gl.activeTexture(GL_TEXTURE0+ndx);
537 gl.bindTexture(texTarget, texObj);
538 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_S, glu::getGLWrapMode(sampler.wrapS));
539 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_T, glu::getGLWrapMode(sampler.wrapT));
540 gl.texParameteri(texTarget, GL_TEXTURE_MIN_FILTER, glu::getGLFilterMode(sampler.minFilter));
541 gl.texParameteri(texTarget, GL_TEXTURE_MAG_FILTER, glu::getGLFilterMode(sampler.magFilter));
542
543 if (texTarget == GL_TEXTURE_3D)
544 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_R, glu::getGLWrapMode(sampler.wrapR));
545
546 if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE)
547 {
548 gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
549 gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_FUNC, glu::getGLCompareFunc(sampler.compare));
550 }
551 }
552
553 GLU_EXPECT_NO_ERROR(gl.getError(), "texture sampler setup");
554 }
555
getDefaultVertexArrays(const glw::Functions & gl,const QuadGrid & quadGrid,deUint32 program,vector<VertexArrayBinding> & vertexArrays)556 static void getDefaultVertexArrays (const glw::Functions& gl, const QuadGrid& quadGrid, deUint32 program, vector<VertexArrayBinding>& vertexArrays)
557 {
558 const int numElements = quadGrid.getNumVertices();
559
560 vertexArrays.push_back(va::Float("a_position", 4, numElements, 0, (const float*)quadGrid.getPositions()));
561 vertexArrays.push_back(va::Float("a_coords", 4, numElements, 0, (const float*)quadGrid.getCoords()));
562 vertexArrays.push_back(va::Float("a_unitCoords", 4, numElements, 0, (const float*)quadGrid.getUnitCoords()));
563 vertexArrays.push_back(va::Float("a_one", 1, numElements, 0, quadGrid.getAttribOne()));
564
565 // a_inN.
566 for (int userNdx = 0; userNdx < quadGrid.getNumUserAttribs(); userNdx++)
567 {
568 string name = string("a_in") + de::toString(userNdx);
569 vertexArrays.push_back(va::Float(name, 4, numElements, 0, (const float*)quadGrid.getUserAttrib(userNdx)));
570 }
571
572 // Matrix attributes - these are set by location
573 static const struct
574 {
575 const char* name;
576 int numCols;
577 int numRows;
578 } matrices[] =
579 {
580 { "a_mat2", 2, 2 },
581 { "a_mat2x3", 2, 3 },
582 { "a_mat2x4", 2, 4 },
583 { "a_mat3x2", 3, 2 },
584 { "a_mat3", 3, 3 },
585 { "a_mat3x4", 3, 4 },
586 { "a_mat4x2", 4, 2 },
587 { "a_mat4x3", 4, 3 },
588 { "a_mat4", 4, 4 }
589 };
590
591 for (int matNdx = 0; matNdx < DE_LENGTH_OF_ARRAY(matrices); matNdx++)
592 {
593 int loc = gl.getAttribLocation(program, matrices[matNdx].name);
594
595 if (loc < 0)
596 continue; // Not used in shader.
597
598 int numRows = matrices[matNdx].numRows;
599 int numCols = matrices[matNdx].numCols;
600
601 for (int colNdx = 0; colNdx < numCols; colNdx++)
602 vertexArrays.push_back(va::Float(loc+colNdx, numRows, numElements, 4*(int)sizeof(float), (const float*)quadGrid.getUserAttrib(colNdx)));
603 }
604 }
605
render(Surface & result,int programID,const QuadGrid & quadGrid)606 void ShaderRenderCase::render (Surface& result, int programID, const QuadGrid& quadGrid)
607 {
608 const glw::Functions& gl = m_renderCtx.getFunctions();
609
610 GLU_EXPECT_NO_ERROR(gl.getError(), "pre render");
611
612 // Buffer info.
613 int width = result.getWidth();
614 int height = result.getHeight();
615
616 int xOffsetMax = m_renderCtx.getRenderTarget().getWidth() - width;
617 int yOffsetMax = m_renderCtx.getRenderTarget().getHeight() - height;
618
619 deUint32 hash = deStringHash(m_vertShaderSource.c_str()) + deStringHash(m_fragShaderSource.c_str());
620 de::Random rnd (hash);
621
622 int xOffset = rnd.getInt(0, xOffsetMax);
623 int yOffset = rnd.getInt(0, yOffsetMax);
624
625 gl.viewport(xOffset, yOffset, width, height);
626
627 // Setup program.
628 setupUniforms(programID, quadGrid.getConstCoords());
629 setupDefaultInputs(programID);
630
631 // Clear.
632 gl.clearColor(m_clearColor.x(), m_clearColor.y(), m_clearColor.z(), m_clearColor.w());
633 gl.clear(GL_COLOR_BUFFER_BIT);
634
635 // Draw.
636 {
637 std::vector<VertexArrayBinding> vertexArrays;
638 const int numElements = quadGrid.getNumTriangles()*3;
639
640 getDefaultVertexArrays(gl, quadGrid, programID, vertexArrays);
641 draw(m_renderCtx, programID, (int)vertexArrays.size(), &vertexArrays[0], pr::Triangles(numElements, quadGrid.getIndices()));
642 }
643 GLU_EXPECT_NO_ERROR(gl.getError(), "draw");
644
645 // Read back results.
646 glu::readPixels(m_renderCtx, xOffset, yOffset, result.getAccess());
647
648 GLU_EXPECT_NO_ERROR(gl.getError(), "post render");
649 }
650
computeVertexReference(Surface & result,const QuadGrid & quadGrid)651 void ShaderRenderCase::computeVertexReference (Surface& result, const QuadGrid& quadGrid)
652 {
653 // Buffer info.
654 int width = result.getWidth();
655 int height = result.getHeight();
656 int gridSize = quadGrid.getGridSize();
657 int stride = gridSize + 1;
658 bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
659 ShaderEvalContext evalCtx (quadGrid);
660
661 // Evaluate color for each vertex.
662 vector<Vec4> colors((gridSize+1)*(gridSize+1));
663 for (int y = 0; y < gridSize+1; y++)
664 for (int x = 0; x < gridSize+1; x++)
665 {
666 float sx = x / (float)gridSize;
667 float sy = y / (float)gridSize;
668 int vtxNdx = ((y * (gridSize+1)) + x);
669
670 evalCtx.reset(sx, sy);
671 m_evaluator.evaluate(evalCtx);
672 DE_ASSERT(!evalCtx.isDiscarded); // Discard is not available in vertex shader.
673 Vec4 color = evalCtx.color;
674
675 if (!hasAlpha)
676 color.w() = 1.0f;
677
678 colors[vtxNdx] = color;
679 }
680
681 // Render quads.
682 for (int y = 0; y < gridSize; y++)
683 for (int x = 0; x < gridSize; x++)
684 {
685 float x0 = x / (float)gridSize;
686 float x1 = (x + 1) / (float)gridSize;
687 float y0 = y / (float)gridSize;
688 float y1 = (y + 1) / (float)gridSize;
689
690 float sx0 = x0 * (float)width;
691 float sx1 = x1 * (float)width;
692 float sy0 = y0 * (float)height;
693 float sy1 = y1 * (float)height;
694 float oosx = 1.0f / (sx1 - sx0);
695 float oosy = 1.0f / (sy1 - sy0);
696
697 int ix0 = deCeilFloatToInt32(sx0 - 0.5f);
698 int ix1 = deCeilFloatToInt32(sx1 - 0.5f);
699 int iy0 = deCeilFloatToInt32(sy0 - 0.5f);
700 int iy1 = deCeilFloatToInt32(sy1 - 0.5f);
701
702 int v00 = (y * stride) + x;
703 int v01 = (y * stride) + x + 1;
704 int v10 = ((y + 1) * stride) + x;
705 int v11 = ((y + 1) * stride) + x + 1;
706 Vec4 c00 = colors[v00];
707 Vec4 c01 = colors[v01];
708 Vec4 c10 = colors[v10];
709 Vec4 c11 = colors[v11];
710
711 //printf("(%d,%d) -> (%f..%f, %f..%f) (%d..%d, %d..%d)\n", x, y, sx0, sx1, sy0, sy1, ix0, ix1, iy0, iy1);
712
713 for (int iy = iy0; iy < iy1; iy++)
714 for (int ix = ix0; ix < ix1; ix++)
715 {
716 DE_ASSERT(deInBounds32(ix, 0, width));
717 DE_ASSERT(deInBounds32(iy, 0, height));
718
719 float sfx = (float)ix + 0.5f;
720 float sfy = (float)iy + 0.5f;
721 float fx1 = deFloatClamp((sfx - sx0) * oosx, 0.0f, 1.0f);
722 float fy1 = deFloatClamp((sfy - sy0) * oosy, 0.0f, 1.0f);
723
724 // Triangle quad interpolation.
725 bool tri = fx1 + fy1 <= 1.0f;
726 float tx = tri ? fx1 : (1.0f-fx1);
727 float ty = tri ? fy1 : (1.0f-fy1);
728 const Vec4& t0 = tri ? c00 : c11;
729 const Vec4& t1 = tri ? c01 : c10;
730 const Vec4& t2 = tri ? c10 : c01;
731 Vec4 color = t0 + (t1-t0)*tx + (t2-t0)*ty;
732
733 result.setPixel(ix, iy, toRGBA(color));
734 }
735 }
736 }
737
computeFragmentReference(Surface & result,const QuadGrid & quadGrid)738 void ShaderRenderCase::computeFragmentReference (Surface& result, const QuadGrid& quadGrid)
739 {
740 // Buffer info.
741 int width = result.getWidth();
742 int height = result.getHeight();
743 bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
744 ShaderEvalContext evalCtx (quadGrid);
745
746 // Render.
747 for (int y = 0; y < height; y++)
748 for (int x = 0; x < width; x++)
749 {
750 float sx = ((float)x + 0.5f) / (float)width;
751 float sy = ((float)y + 0.5f) / (float)height;
752
753 evalCtx.reset(sx, sy);
754 m_evaluator.evaluate(evalCtx);
755 // Select either clear color or computed color based on discarded bit.
756 Vec4 color = evalCtx.isDiscarded ? m_clearColor : evalCtx.color;
757
758 if (!hasAlpha)
759 color.w() = 1.0f;
760
761 result.setPixel(x, y, toRGBA(color));
762 }
763 }
764
compareImages(const Surface & resImage,const Surface & refImage,float errorThreshold)765 bool ShaderRenderCase::compareImages (const Surface& resImage, const Surface& refImage, float errorThreshold)
766 {
767 return tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", refImage, resImage, errorThreshold, tcu::COMPARE_LOG_RESULT);
768 }
769
770 // Uniform name helpers.
771
getIntUniformName(int number)772 const char* getIntUniformName (int number)
773 {
774 switch (number)
775 {
776 case 0: return "ui_zero";
777 case 1: return "ui_one";
778 case 2: return "ui_two";
779 case 3: return "ui_three";
780 case 4: return "ui_four";
781 case 5: return "ui_five";
782 case 6: return "ui_six";
783 case 7: return "ui_seven";
784 case 8: return "ui_eight";
785 case 101: return "ui_oneHundredOne";
786 default:
787 DE_ASSERT(false);
788 return "";
789 }
790 }
791
getFloatUniformName(int number)792 const char* getFloatUniformName (int number)
793 {
794 switch (number)
795 {
796 case 0: return "uf_zero";
797 case 1: return "uf_one";
798 case 2: return "uf_two";
799 case 3: return "uf_three";
800 case 4: return "uf_four";
801 case 5: return "uf_five";
802 case 6: return "uf_six";
803 case 7: return "uf_seven";
804 case 8: return "uf_eight";
805 default:
806 DE_ASSERT(false);
807 return "";
808 }
809 }
810
getFloatFractionUniformName(int number)811 const char* getFloatFractionUniformName (int number)
812 {
813 switch (number)
814 {
815 case 1: return "uf_one";
816 case 2: return "uf_half";
817 case 3: return "uf_third";
818 case 4: return "uf_fourth";
819 case 5: return "uf_fifth";
820 case 6: return "uf_sixth";
821 case 7: return "uf_seventh";
822 case 8: return "uf_eighth";
823 default:
824 DE_ASSERT(false);
825 return "";
826 }
827 }
828
setupDefaultUniforms(const glu::RenderContext & context,deUint32 programID)829 void setupDefaultUniforms (const glu::RenderContext& context, deUint32 programID)
830 {
831 const glw::Functions& gl = context.getFunctions();
832
833 // Bool.
834 struct BoolUniform { const char* name; bool value; };
835 static const BoolUniform s_boolUniforms[] =
836 {
837 { "ub_true", true },
838 { "ub_false", false },
839 };
840
841 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_boolUniforms); i++)
842 {
843 int uniLoc = gl.getUniformLocation(programID, s_boolUniforms[i].name);
844 if (uniLoc != -1)
845 gl.uniform1i(uniLoc, s_boolUniforms[i].value);
846 }
847
848 // BVec4.
849 struct BVec4Uniform { const char* name; BVec4 value; };
850 static const BVec4Uniform s_bvec4Uniforms[] =
851 {
852 { "ub4_true", BVec4(true) },
853 { "ub4_false", BVec4(false) },
854 };
855
856 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_bvec4Uniforms); i++)
857 {
858 const BVec4Uniform& uni = s_bvec4Uniforms[i];
859 int arr[4];
860 arr[0] = (int)uni.value.x();
861 arr[1] = (int)uni.value.y();
862 arr[2] = (int)uni.value.z();
863 arr[3] = (int)uni.value.w();
864 int uniLoc = gl.getUniformLocation(programID, uni.name);
865 if (uniLoc != -1)
866 gl.uniform4iv(uniLoc, 1, &arr[0]);
867 }
868
869 // Int.
870 struct IntUniform { const char* name; int value; };
871 static const IntUniform s_intUniforms[] =
872 {
873 { "ui_minusOne", -1 },
874 { "ui_zero", 0 },
875 { "ui_one", 1 },
876 { "ui_two", 2 },
877 { "ui_three", 3 },
878 { "ui_four", 4 },
879 { "ui_five", 5 },
880 { "ui_six", 6 },
881 { "ui_seven", 7 },
882 { "ui_eight", 8 },
883 { "ui_oneHundredOne", 101 }
884 };
885
886 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_intUniforms); i++)
887 {
888 int uniLoc = gl.getUniformLocation(programID, s_intUniforms[i].name);
889 if (uniLoc != -1)
890 gl.uniform1i(uniLoc, s_intUniforms[i].value);
891 }
892
893 // IVec2.
894 struct IVec2Uniform { const char* name; IVec2 value; };
895 static const IVec2Uniform s_ivec2Uniforms[] =
896 {
897 { "ui2_minusOne", IVec2(-1) },
898 { "ui2_zero", IVec2(0) },
899 { "ui2_one", IVec2(1) },
900 { "ui2_two", IVec2(2) },
901 { "ui2_four", IVec2(4) },
902 { "ui2_five", IVec2(5) }
903 };
904
905 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec2Uniforms); i++)
906 {
907 int uniLoc = gl.getUniformLocation(programID, s_ivec2Uniforms[i].name);
908 if (uniLoc != -1)
909 gl.uniform2iv(uniLoc, 1, s_ivec2Uniforms[i].value.getPtr());
910 }
911
912 // IVec3.
913 struct IVec3Uniform { const char* name; IVec3 value; };
914 static const IVec3Uniform s_ivec3Uniforms[] =
915 {
916 { "ui3_minusOne", IVec3(-1) },
917 { "ui3_zero", IVec3(0) },
918 { "ui3_one", IVec3(1) },
919 { "ui3_two", IVec3(2) },
920 { "ui3_four", IVec3(4) },
921 { "ui3_five", IVec3(5) }
922 };
923
924 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec3Uniforms); i++)
925 {
926 int uniLoc = gl.getUniformLocation(programID, s_ivec3Uniforms[i].name);
927 if (uniLoc != -1)
928 gl.uniform3iv(uniLoc, 1, s_ivec3Uniforms[i].value.getPtr());
929 }
930
931 // IVec4.
932 struct IVec4Uniform { const char* name; IVec4 value; };
933 static const IVec4Uniform s_ivec4Uniforms[] =
934 {
935 { "ui4_minusOne", IVec4(-1) },
936 { "ui4_zero", IVec4(0) },
937 { "ui4_one", IVec4(1) },
938 { "ui4_two", IVec4(2) },
939 { "ui4_four", IVec4(4) },
940 { "ui4_five", IVec4(5) }
941 };
942
943 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec4Uniforms); i++)
944 {
945 int uniLoc = gl.getUniformLocation(programID, s_ivec4Uniforms[i].name);
946 if (uniLoc != -1)
947 gl.uniform4iv(uniLoc, 1, s_ivec4Uniforms[i].value.getPtr());
948 }
949
950 // Float.
951 struct FloatUniform { const char* name; float value; };
952 static const FloatUniform s_floatUniforms[] =
953 {
954 { "uf_zero", 0.0f },
955 { "uf_one", 1.0f },
956 { "uf_two", 2.0f },
957 { "uf_three", 3.0f },
958 { "uf_four", 4.0f },
959 { "uf_five", 5.0f },
960 { "uf_six", 6.0f },
961 { "uf_seven", 7.0f },
962 { "uf_eight", 8.0f },
963 { "uf_half", 1.0f / 2.0f },
964 { "uf_third", 1.0f / 3.0f },
965 { "uf_fourth", 1.0f / 4.0f },
966 { "uf_fifth", 1.0f / 5.0f },
967 { "uf_sixth", 1.0f / 6.0f },
968 { "uf_seventh", 1.0f / 7.0f },
969 { "uf_eighth", 1.0f / 8.0f }
970 };
971
972 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_floatUniforms); i++)
973 {
974 int uniLoc = gl.getUniformLocation(programID, s_floatUniforms[i].name);
975 if (uniLoc != -1)
976 gl.uniform1f(uniLoc, s_floatUniforms[i].value);
977 }
978
979 // Vec2.
980 struct Vec2Uniform { const char* name; Vec2 value; };
981 static const Vec2Uniform s_vec2Uniforms[] =
982 {
983 { "uv2_minusOne", Vec2(-1.0f) },
984 { "uv2_zero", Vec2(0.0f) },
985 { "uv2_half", Vec2(0.5f) },
986 { "uv2_one", Vec2(1.0f) },
987 { "uv2_two", Vec2(2.0f) },
988 };
989
990 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec2Uniforms); i++)
991 {
992 int uniLoc = gl.getUniformLocation(programID, s_vec2Uniforms[i].name);
993 if (uniLoc != -1)
994 gl.uniform2fv(uniLoc, 1, s_vec2Uniforms[i].value.getPtr());
995 }
996
997 // Vec3.
998 struct Vec3Uniform { const char* name; Vec3 value; };
999 static const Vec3Uniform s_vec3Uniforms[] =
1000 {
1001 { "uv3_minusOne", Vec3(-1.0f) },
1002 { "uv3_zero", Vec3(0.0f) },
1003 { "uv3_half", Vec3(0.5f) },
1004 { "uv3_one", Vec3(1.0f) },
1005 { "uv3_two", Vec3(2.0f) },
1006 };
1007
1008 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec3Uniforms); i++)
1009 {
1010 int uniLoc = gl.getUniformLocation(programID, s_vec3Uniforms[i].name);
1011 if (uniLoc != -1)
1012 gl.uniform3fv(uniLoc, 1, s_vec3Uniforms[i].value.getPtr());
1013 }
1014
1015 // Vec4.
1016 struct Vec4Uniform { const char* name; Vec4 value; };
1017 static const Vec4Uniform s_vec4Uniforms[] =
1018 {
1019 { "uv4_minusOne", Vec4(-1.0f) },
1020 { "uv4_zero", Vec4(0.0f) },
1021 { "uv4_half", Vec4(0.5f) },
1022 { "uv4_one", Vec4(1.0f) },
1023 { "uv4_two", Vec4(2.0f) },
1024 { "uv4_black", Vec4(0.0f, 0.0f, 0.0f, 1.0f) },
1025 { "uv4_gray", Vec4(0.5f, 0.5f, 0.5f, 1.0f) },
1026 { "uv4_white", Vec4(1.0f, 1.0f, 1.0f, 1.0f) },
1027 };
1028
1029 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec4Uniforms); i++)
1030 {
1031 int uniLoc = gl.getUniformLocation(programID, s_vec4Uniforms[i].name);
1032 if (uniLoc != -1)
1033 gl.uniform4fv(uniLoc, 1, s_vec4Uniforms[i].value.getPtr());
1034 }
1035 }
1036
1037 } // gls
1038 } // deqp
1039