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 - render state interaction case.
22 *//*--------------------------------------------------------------------*/
23
24 #include "glsFragOpInteractionCase.hpp"
25
26 #include "glsRandomShaderProgram.hpp"
27 #include "glsFragmentOpUtil.hpp"
28 #include "glsInteractionTestUtil.hpp"
29
30 #include "gluRenderContext.hpp"
31 #include "gluContextInfo.hpp"
32
33 #include "rsgShader.hpp"
34 #include "rsgProgramGenerator.hpp"
35 #include "rsgUtils.hpp"
36
37 #include "sglrContext.hpp"
38 #include "sglrReferenceContext.hpp"
39 #include "sglrGLContext.hpp"
40 #include "sglrContextUtil.hpp"
41
42 #include "tcuRenderTarget.hpp"
43 #include "tcuImageCompare.hpp"
44
45 #include "deRandom.hpp"
46 #include "deString.h"
47 #include "deStringUtil.hpp"
48
49 #include "glwEnums.hpp"
50
51 #include "gluDrawUtil.hpp"
52
53 namespace deqp
54 {
55 namespace gls
56 {
57
58 using std::vector;
59 using std::string;
60 using tcu::Vec2;
61 using tcu::Vec4;
62 using tcu::IVec2;
63 using tcu::IVec4;
64
65 using gls::InteractionTestUtil::RenderState;
66 using gls::InteractionTestUtil::StencilState;
67
68 enum
69 {
70 NUM_ITERATIONS = 5,
71 NUM_COMMANDS_PER_ITERATION = 5,
72 VIEWPORT_WIDTH = 64,
73 VIEWPORT_HEIGHT = 64
74 };
75
76 namespace
77 {
78
computeVertexLayout(const vector<rsg::ShaderInput * > & attributes,int numVertices,vector<glu::VertexArrayBinding> * layout,int * stride)79 static void computeVertexLayout (const vector<rsg::ShaderInput*>& attributes, int numVertices, vector<glu::VertexArrayBinding>* layout, int* stride)
80 {
81 DE_ASSERT(layout->empty());
82
83 int curOffset = 0;
84
85 for (vector<rsg::ShaderInput*>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
86 {
87 const rsg::ShaderInput* attrib = *iter;
88 const rsg::Variable* var = attrib->getVariable();
89 const rsg::VariableType& type = var->getType();
90 const int numComps = type.getNumElements();
91
92 TCU_CHECK_INTERNAL(type.getBaseType() == rsg::VariableType::TYPE_FLOAT && de::inRange(type.getNumElements(), 1, 4));
93
94 layout->push_back(glu::va::Float(var->getName(), numComps, numVertices, 0 /* computed later */, (const float*)(deUintptr)curOffset));
95
96 curOffset += numComps * (int)sizeof(float);
97 }
98
99 for (vector<glu::VertexArrayBinding>::iterator vaIter = layout->begin(); vaIter != layout->end(); ++vaIter)
100 vaIter->pointer.stride = curOffset;
101
102 *stride = curOffset;
103 }
104
105 class VertexDataStorage
106 {
107 public:
108 VertexDataStorage (const vector<rsg::ShaderInput*>& attributes, int numVertices);
109
getDataSize(void) const110 int getDataSize (void) const { return (int)m_data.size(); }
getBasePtr(void)111 void* getBasePtr (void) { return m_data.empty() ? DE_NULL : &m_data[0]; }
getBasePtr(void) const112 const void* getBasePtr (void) const { return m_data.empty() ? DE_NULL : &m_data[0]; }
113
getLayout(void) const114 const std::vector<glu::VertexArrayBinding>& getLayout (void) const { return m_layout; }
115
getNumEntries(void) const116 int getNumEntries (void) const { return (int)m_layout.size(); }
getLayoutEntry(int ndx) const117 const glu::VertexArrayBinding& getLayoutEntry (int ndx) const { return m_layout[ndx]; }
118
119 private:
120 std::vector<deUint8> m_data;
121 std::vector<glu::VertexArrayBinding> m_layout;
122 };
123
VertexDataStorage(const vector<rsg::ShaderInput * > & attributes,int numVertices)124 VertexDataStorage::VertexDataStorage (const vector<rsg::ShaderInput*>& attributes, int numVertices)
125 {
126 int stride = 0;
127 computeVertexLayout(attributes, numVertices, &m_layout, &stride);
128 m_data.resize(stride * numVertices);
129 }
130
getEntryWithPointer(const VertexDataStorage & data,int ndx)131 static inline glu::VertexArrayBinding getEntryWithPointer (const VertexDataStorage& data, int ndx)
132 {
133 const glu::VertexArrayBinding& entry = data.getLayoutEntry(ndx);
134 return glu::VertexArrayBinding(entry.binding, glu::VertexArrayPointer(entry.pointer.componentType,
135 entry.pointer.convert,
136 entry.pointer.numComponents,
137 entry.pointer.numElements,
138 entry.pointer.stride,
139 (const void*)((deUintptr)entry.pointer.data+(deUintptr)data.getBasePtr())));
140 }
141
142 template<int Size>
setVertex(const glu::VertexArrayPointer & pointer,int vertexNdx,const tcu::Vector<float,Size> & value)143 static void setVertex (const glu::VertexArrayPointer& pointer, int vertexNdx, const tcu::Vector<float, Size>& value)
144 {
145 // \todo [2013-12-14 pyry] Implement other modes.
146 DE_ASSERT(pointer.componentType == glu::VTX_COMP_FLOAT && pointer.convert == glu::VTX_COMP_CONVERT_NONE);
147 DE_ASSERT(pointer.numComponents == Size);
148 DE_ASSERT(de::inBounds(vertexNdx, 0, pointer.numElements));
149
150 float* dst = (float*)((deUint8*)pointer.data + pointer.stride*vertexNdx);
151
152 for (int ndx = 0; ndx < Size; ndx++)
153 dst[ndx] = value[ndx];
154 }
155
156 template<int Size>
interpolateRange(const rsg::ConstValueRangeAccess & range,const tcu::Vector<float,Size> & t)157 static tcu::Vector<float, Size> interpolateRange (const rsg::ConstValueRangeAccess& range, const tcu::Vector<float, Size>& t)
158 {
159 tcu::Vector<float, Size> result;
160
161 for (int ndx = 0; ndx < Size; ndx++)
162 result[ndx] = range.getMin().component(ndx).asFloat()*(1.0f - t[ndx]) + range.getMax().component(ndx).asFloat()*t[ndx];
163
164 return result;
165 }
166
167 struct Quad
168 {
169 tcu::IVec2 posA;
170 tcu::IVec2 posB;
171 };
172
173 struct RenderCommand
174 {
175 Quad quad;
176 float depth;
177 RenderState state;
178
RenderCommanddeqp::gls::__anon184b1da60211::RenderCommand179 RenderCommand (void) : depth(0.0f) {}
180 };
181
getRandomQuad(de::Random & rnd,int targetW,int targetH)182 static Quad getRandomQuad (de::Random& rnd, int targetW, int targetH)
183 {
184 // \note In viewport coordinates.
185 // \todo [2012-12-18 pyry] Out-of-bounds values.
186 const int maxOutOfBounds = 0;
187 const float minSize = 0.5f;
188
189 const int minW = deCeilFloatToInt32(minSize * (float)targetW);
190 const int minH = deCeilFloatToInt32(minSize * (float)targetH);
191 const int maxW = targetW + 2*maxOutOfBounds;
192 const int maxH = targetH + 2*maxOutOfBounds;
193
194 const int width = rnd.getInt(minW, maxW);
195 const int height = rnd.getInt(minH, maxH);
196 const int x = rnd.getInt(-maxOutOfBounds, targetW+maxOutOfBounds-width);
197 const int y = rnd.getInt(-maxOutOfBounds, targetH+maxOutOfBounds-height);
198
199 const bool flipX = rnd.getBool();
200 const bool flipY = rnd.getBool();
201
202 Quad quad;
203
204 quad.posA = tcu::IVec2(flipX ? (x+width-1) : x, flipY ? (y+height-1) : y);
205 quad.posB = tcu::IVec2(flipX ? x : (x+width-1), flipY ? y : (y+height-1));
206
207 return quad;
208 }
209
getRandomDepth(de::Random & rnd)210 static float getRandomDepth (de::Random& rnd)
211 {
212 // \note Not using depth 1.0 since clearing with 1.0 and rendering with 1.0 may not be same value.
213 static const float depthValues[] = { 0.0f, 0.2f, 0.4f, 0.5f, 0.51f, 0.6f, 0.8f, 0.95f };
214 return rnd.choose<float>(DE_ARRAY_BEGIN(depthValues), DE_ARRAY_END(depthValues));
215 }
216
computeRandomRenderCommand(de::Random & rnd,RenderCommand & command,glu::ApiType apiType,int targetW,int targetH)217 static void computeRandomRenderCommand (de::Random& rnd, RenderCommand& command, glu::ApiType apiType, int targetW, int targetH)
218 {
219 command.quad = getRandomQuad(rnd, targetW, targetH);
220 command.depth = getRandomDepth(rnd);
221 gls::InteractionTestUtil::computeRandomRenderState(rnd, command.state, apiType, targetW, targetH);
222 }
223
setRenderState(sglr::Context & ctx,const RenderState & state)224 static void setRenderState (sglr::Context& ctx, const RenderState& state)
225 {
226 if (state.scissorTestEnabled)
227 {
228 ctx.enable(GL_SCISSOR_TEST);
229 ctx.scissor(state.scissorRectangle.left, state.scissorRectangle.bottom,
230 state.scissorRectangle.width, state.scissorRectangle.height);
231 }
232 else
233 ctx.disable(GL_SCISSOR_TEST);
234
235 if (state.stencilTestEnabled)
236 {
237 ctx.enable(GL_STENCIL_TEST);
238
239 for (int face = 0; face < rr::FACETYPE_LAST; face++)
240 {
241 deUint32 glFace = face == rr::FACETYPE_BACK ? GL_BACK : GL_FRONT;
242 const StencilState& sParams = state.stencil[face];
243
244 ctx.stencilFuncSeparate(glFace, sParams.function, sParams.reference, sParams.compareMask);
245 ctx.stencilOpSeparate(glFace, sParams.stencilFailOp, sParams.depthFailOp, sParams.depthPassOp);
246 ctx.stencilMaskSeparate(glFace, sParams.writeMask);
247 }
248 }
249 else
250 ctx.disable(GL_STENCIL_TEST);
251
252 if (state.depthTestEnabled)
253 {
254 ctx.enable(GL_DEPTH_TEST);
255 ctx.depthFunc(state.depthFunc);
256 ctx.depthMask(state.depthWriteMask ? GL_TRUE : GL_FALSE);
257 }
258 else
259 ctx.disable(GL_DEPTH_TEST);
260
261 if (state.blendEnabled)
262 {
263 ctx.enable(GL_BLEND);
264 ctx.blendEquationSeparate(state.blendRGBState.equation, state.blendAState.equation);
265 ctx.blendFuncSeparate(state.blendRGBState.srcFunc, state.blendRGBState.dstFunc, state.blendAState.srcFunc, state.blendAState.dstFunc);
266 ctx.blendColor(state.blendColor.x(), state.blendColor.y(), state.blendColor.z(), state.blendColor.w());
267 }
268 else
269 ctx.disable(GL_BLEND);
270
271 if (state.ditherEnabled)
272 ctx.enable(GL_DITHER);
273 else
274 ctx.disable(GL_DITHER);
275
276 ctx.colorMask(state.colorMask[0] ? GL_TRUE : GL_FALSE,
277 state.colorMask[1] ? GL_TRUE : GL_FALSE,
278 state.colorMask[2] ? GL_TRUE : GL_FALSE,
279 state.colorMask[3] ? GL_TRUE : GL_FALSE);
280 }
281
renderQuad(sglr::Context & ctx,const glu::VertexArrayPointer & posPtr,const Quad & quad,const float depth)282 static void renderQuad (sglr::Context& ctx, const glu::VertexArrayPointer& posPtr, const Quad& quad, const float depth)
283 {
284 const deUint16 indices[] = { 0, 1, 2, 2, 1, 3 };
285
286 const bool flipX = quad.posB.x() < quad.posA.x();
287 const bool flipY = quad.posB.y() < quad.posA.y();
288 const int viewportX = de::min(quad.posA.x(), quad.posB.x());
289 const int viewportY = de::min(quad.posA.y(), quad.posB.y());
290 const int viewportW = de::abs(quad.posA.x()-quad.posB.x())+1;
291 const int viewportH = de::abs(quad.posA.y()-quad.posB.y())+1;
292
293 const Vec2 pA (flipX ? 1.0f : -1.0f, flipY ? 1.0f : -1.0f);
294 const Vec2 pB (flipX ? -1.0f : 1.0f, flipY ? -1.0f : 1.0f);
295
296 setVertex(posPtr, 0, Vec4(pA.x(), pA.y(), depth, 1.0f));
297 setVertex(posPtr, 1, Vec4(pB.x(), pA.y(), depth, 1.0f));
298 setVertex(posPtr, 2, Vec4(pA.x(), pB.y(), depth, 1.0f));
299 setVertex(posPtr, 3, Vec4(pB.x(), pB.y(), depth, 1.0f));
300
301 ctx.viewport(viewportX, viewportY, viewportW, viewportH);
302 ctx.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0]);
303 }
304
render(sglr::Context & ctx,const glu::VertexArrayPointer & posPtr,const RenderCommand & cmd)305 static void render (sglr::Context& ctx, const glu::VertexArrayPointer& posPtr, const RenderCommand& cmd)
306 {
307 setRenderState(ctx, cmd.state);
308 renderQuad(ctx, posPtr, cmd.quad, cmd.depth);
309 }
310
setupAttributes(sglr::Context & ctx,const VertexDataStorage & vertexData,deUint32 program)311 static void setupAttributes (sglr::Context& ctx, const VertexDataStorage& vertexData, deUint32 program)
312 {
313 for (int attribNdx = 0; attribNdx < vertexData.getNumEntries(); ++attribNdx)
314 {
315 const glu::VertexArrayBinding bindingPtr = getEntryWithPointer(vertexData, attribNdx);
316 const int attribLoc = bindingPtr.binding.type == glu::BindingPoint::TYPE_NAME ? ctx.getAttribLocation(program, bindingPtr.binding.name.c_str()) : bindingPtr.binding.location;
317
318 DE_ASSERT(bindingPtr.pointer.componentType == glu::VTX_COMP_FLOAT);
319
320 if (attribLoc >= 0)
321 {
322 ctx.enableVertexAttribArray(attribLoc);
323 ctx.vertexAttribPointer(attribLoc, bindingPtr.pointer.numComponents, GL_FLOAT, GL_FALSE, bindingPtr.pointer.stride, bindingPtr.pointer.data);
324 }
325 }
326 }
327
setUniformValue(sglr::Context & ctx,int location,rsg::ConstValueAccess value)328 void setUniformValue (sglr::Context& ctx, int location, rsg::ConstValueAccess value)
329 {
330 DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(float));
331 DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(int));
332
333 switch (value.getType().getBaseType())
334 {
335 case rsg::VariableType::TYPE_FLOAT:
336 switch (value.getType().getNumElements())
337 {
338 case 1: ctx.uniform1fv(location, 1, (float*)value.value().getValuePtr()); break;
339 case 2: ctx.uniform2fv(location, 1, (float*)value.value().getValuePtr()); break;
340 case 3: ctx.uniform3fv(location, 1, (float*)value.value().getValuePtr()); break;
341 case 4: ctx.uniform4fv(location, 1, (float*)value.value().getValuePtr()); break;
342 default: TCU_FAIL("Unsupported type"); break;
343 }
344 break;
345
346 case rsg::VariableType::TYPE_INT:
347 case rsg::VariableType::TYPE_BOOL:
348 case rsg::VariableType::TYPE_SAMPLER_2D:
349 case rsg::VariableType::TYPE_SAMPLER_CUBE:
350 switch (value.getType().getNumElements())
351 {
352 case 1: ctx.uniform1iv(location, 1, (int*)value.value().getValuePtr()); break;
353 case 2: ctx.uniform2iv(location, 1, (int*)value.value().getValuePtr()); break;
354 case 3: ctx.uniform3iv(location, 1, (int*)value.value().getValuePtr()); break;
355 case 4: ctx.uniform4iv(location, 1, (int*)value.value().getValuePtr()); break;
356 default: TCU_FAIL("Unsupported type"); break;
357 }
358 break;
359
360 default:
361 throw tcu::InternalError("Unsupported type", "", __FILE__, __LINE__);
362 }
363 }
364
findShaderInputIndex(const vector<rsg::ShaderInput * > & vars,const char * name)365 static int findShaderInputIndex (const vector<rsg::ShaderInput*>& vars, const char* name)
366 {
367 for (int ndx = 0; ndx < (int)vars.size(); ++ndx)
368 {
369 if (deStringEqual(vars[ndx]->getVariable()->getName(), name))
370 return ndx;
371 }
372
373 throw tcu::InternalError(string(name) + " not found in shader inputs");
374 }
375
getWellBehavingChannelColor(float v,int numBits)376 static float getWellBehavingChannelColor (float v, int numBits)
377 {
378 DE_ASSERT(de::inRange(numBits, 0, 32));
379
380 // clear color may not be accurately representable in the target format. If the clear color is
381 // on a representable value mapping range border, it could be rounded differently by the GL and in
382 // SGLR adding an unexpected error source. However, selecting an accurately representable background
383 // color would effectively disable dithering. To allow dithering and to prevent undefined rounding
384 // direction from affecting results, round accurate color to target color format with 8 sub-units
385 // (3 bits). If the selected sub-unit value is 3 or 4 (bordering 0.5), replace it with 2 and 5,
386 // respectively.
387
388 if (numBits == 0 || v <= 0.0f || v >= 1.0f)
389 {
390 // already accurately representable
391 return v;
392 }
393 else
394 {
395 const deUint64 numSubBits = 3;
396 const deUint64 subUnitBorderLo = (1u << (numSubBits - 1u)) - 1u;
397 const deUint64 subUnitBorderHi = 1u << (numSubBits - 1u);
398 const deUint64 maxFixedValue = (1u << (numBits + numSubBits)) - 1u;
399 const deUint64 fixedValue = deRoundFloatToInt64(v * (float)maxFixedValue);
400
401 const deUint64 units = fixedValue >> numSubBits;
402 const deUint64 subUnits = fixedValue & ((1u << numSubBits) - 1u);
403
404 const deUint64 tweakedSubUnits = (subUnits == subUnitBorderLo) ? (subUnitBorderLo - 1)
405 : (subUnits == subUnitBorderHi) ? (subUnitBorderHi + 1)
406 : (subUnits);
407 const deUint64 tweakedValue = (units << numSubBits) | (tweakedSubUnits);
408
409 return float(tweakedValue) / float(maxFixedValue);
410 }
411 }
412
getWellBehavingColor(const tcu::Vec4 & accurateColor,const tcu::PixelFormat & format)413 static tcu::Vec4 getWellBehavingColor (const tcu::Vec4& accurateColor, const tcu::PixelFormat& format)
414 {
415 return tcu::Vec4(getWellBehavingChannelColor(accurateColor[0], format.redBits),
416 getWellBehavingChannelColor(accurateColor[1], format.greenBits),
417 getWellBehavingChannelColor(accurateColor[2], format.blueBits),
418 getWellBehavingChannelColor(accurateColor[3], format.alphaBits));
419 }
420
421 } // anonymous
422
423 struct FragOpInteractionCase::ReferenceContext
424 {
425 const sglr::ReferenceContextLimits limits;
426 sglr::ReferenceContextBuffers buffers;
427 sglr::ReferenceContext context;
428
ReferenceContextdeqp::gls::FragOpInteractionCase::ReferenceContext429 ReferenceContext (glu::RenderContext& renderCtx, int width, int height)
430 : limits (renderCtx)
431 , buffers (renderCtx.getRenderTarget().getPixelFormat(), renderCtx.getRenderTarget().getDepthBits(), renderCtx.getRenderTarget().getStencilBits(), width, height)
432 , context (limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer())
433 {
434 }
435 };
436
FragOpInteractionCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const glu::ContextInfo & ctxInfo,const char * name,const rsg::ProgramParameters & params)437 FragOpInteractionCase::FragOpInteractionCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const rsg::ProgramParameters& params)
438 : TestCase (testCtx, name, "")
439 , m_renderCtx (renderCtx)
440 , m_ctxInfo (ctxInfo)
441 , m_params (params)
442 , m_vertexShader (rsg::Shader::TYPE_VERTEX)
443 , m_fragmentShader (rsg::Shader::TYPE_FRAGMENT)
444 , m_program (DE_NULL)
445 , m_glCtx (DE_NULL)
446 , m_referenceCtx (DE_NULL)
447 , m_glProgram (0)
448 , m_refProgram (0)
449 , m_iterNdx (0)
450 {
451 }
452
~FragOpInteractionCase(void)453 FragOpInteractionCase::~FragOpInteractionCase (void)
454 {
455 FragOpInteractionCase::deinit();
456 }
457
init(void)458 void FragOpInteractionCase::init (void)
459 {
460 de::Random rnd (m_params.seed ^ 0x232faac);
461 const int viewportW = de::min<int>(m_renderCtx.getRenderTarget().getWidth(), VIEWPORT_WIDTH);
462 const int viewportH = de::min<int>(m_renderCtx.getRenderTarget().getHeight(), VIEWPORT_HEIGHT);
463 const int viewportX = rnd.getInt(0, m_renderCtx.getRenderTarget().getWidth() - viewportW);
464 const int viewportY = rnd.getInt(0, m_renderCtx.getRenderTarget().getHeight() - viewportH);
465
466 rsg::ProgramGenerator generator;
467
468 generator.generate(m_params, m_vertexShader, m_fragmentShader);
469 rsg::computeUnifiedUniforms(m_vertexShader, m_fragmentShader, m_unifiedUniforms);
470
471 try
472 {
473 DE_ASSERT(!m_program);
474 m_program = new gls::RandomShaderProgram(m_vertexShader, m_fragmentShader, (int)m_unifiedUniforms.size(), m_unifiedUniforms.empty() ? DE_NULL : &m_unifiedUniforms[0]);
475
476 DE_ASSERT(!m_referenceCtx);
477 m_referenceCtx = new ReferenceContext(m_renderCtx, viewportW, viewportH);
478
479 DE_ASSERT(!m_glCtx);
480 m_glCtx = new sglr::GLContext(m_renderCtx, m_testCtx.getLog(), sglr::GLCONTEXT_LOG_CALLS|sglr::GLCONTEXT_LOG_PROGRAMS, IVec4(viewportX, viewportY, viewportW, viewportH));
481
482 m_refProgram = m_referenceCtx->context.createProgram(m_program);
483 m_glProgram = m_glCtx->createProgram(m_program);
484
485 m_viewportSize = tcu::IVec2(viewportW, viewportH);
486 m_iterNdx = 0;
487 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
488 }
489 catch (...)
490 {
491 // Save some memory by cleaning up stuff.
492 FragOpInteractionCase::deinit();
493 throw;
494 }
495 }
496
deinit(void)497 void FragOpInteractionCase::deinit (void)
498 {
499 delete m_referenceCtx;
500 m_referenceCtx = DE_NULL;
501
502 delete m_glCtx;
503 m_glCtx = DE_NULL;
504
505 delete m_program;
506 m_program = DE_NULL;
507 }
508
iterate(void)509 FragOpInteractionCase::IterateResult FragOpInteractionCase::iterate (void)
510 {
511 de::Random rnd (m_params.seed ^ deInt32Hash(m_iterNdx));
512 const tcu::ScopedLogSection section (m_testCtx.getLog(), string("Iter") + de::toString(m_iterNdx), string("Iteration ") + de::toString(m_iterNdx));
513
514 const int positionNdx = findShaderInputIndex(m_vertexShader.getInputs(), "dEQP_Position");
515
516 const int numVertices = 4;
517 VertexDataStorage vertexData (m_vertexShader.getInputs(), numVertices);
518 std::vector<rsg::VariableValue> uniformValues;
519 std::vector<RenderCommand> renderCmds (NUM_COMMANDS_PER_ITERATION);
520
521 tcu::Surface rendered (m_viewportSize.x(), m_viewportSize.y());
522 tcu::Surface reference (m_viewportSize.x(), m_viewportSize.y());
523
524 const tcu::Vec4 vtxInterpFactors[] =
525 {
526 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
527 tcu::Vec4(1.0f, 0.0f, 0.5f, 0.5f),
528 tcu::Vec4(0.0f, 1.0f, 0.5f, 0.5f),
529 tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)
530 };
531
532 rsg::computeUniformValues(rnd, uniformValues, m_unifiedUniforms);
533
534 for (int attribNdx = 0; attribNdx < (int)m_vertexShader.getInputs().size(); ++attribNdx)
535 {
536 if (attribNdx == positionNdx)
537 continue;
538
539 const rsg::ShaderInput* shaderIn = m_vertexShader.getInputs()[attribNdx];
540 const rsg::VariableType& varType = shaderIn->getVariable()->getType();
541 const rsg::ConstValueRangeAccess valueRange = shaderIn->getValueRange();
542 const int numComponents = varType.getNumElements();
543 const glu::VertexArrayBinding layoutEntry = getEntryWithPointer(vertexData, attribNdx);
544
545 DE_ASSERT(varType.getBaseType() == rsg::VariableType::TYPE_FLOAT);
546
547 for (int vtxNdx = 0; vtxNdx < 4; vtxNdx++)
548 {
549 const int fNdx = (attribNdx+vtxNdx+m_iterNdx)%DE_LENGTH_OF_ARRAY(vtxInterpFactors);
550 const tcu::Vec4& f = vtxInterpFactors[fNdx];
551
552 switch (numComponents)
553 {
554 case 1: setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<1>())); break;
555 case 2: setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<2>())); break;
556 case 3: setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<3>())); break;
557 case 4: setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<4>())); break;
558 default:
559 DE_ASSERT(false);
560 }
561 }
562 }
563
564 for (vector<RenderCommand>::iterator cmdIter = renderCmds.begin(); cmdIter != renderCmds.end(); ++cmdIter)
565 computeRandomRenderCommand(rnd, *cmdIter, m_renderCtx.getType().getAPI(), m_viewportSize.x(), m_viewportSize.y());
566
567 // Workaround for inaccurate barycentric/depth computation in current reference renderer:
568 // Small bias is added to the draw call depths, in increasing order, to avoid accuracy issues in depth comparison.
569 for (int cmdNdx = 0; cmdNdx < (int)renderCmds.size(); cmdNdx++)
570 renderCmds[cmdNdx].depth += 0.0231725f * float(cmdNdx);
571
572 {
573 const glu::VertexArrayPointer posPtr = getEntryWithPointer(vertexData, positionNdx).pointer;
574
575 sglr::Context* const contexts[] = { m_glCtx, &m_referenceCtx->context };
576 const deUint32 programs[] = { m_glProgram, m_refProgram };
577 tcu::PixelBufferAccess readDst[] = { rendered.getAccess(), reference.getAccess() };
578
579 const tcu::Vec4 accurateClearColor = tcu::Vec4(0.0f, 0.25f, 0.5f, 1.0f);
580 const tcu::Vec4 clearColor = getWellBehavingColor(accurateClearColor, m_renderCtx.getRenderTarget().getPixelFormat());
581
582 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(contexts); ndx++)
583 {
584 sglr::Context& ctx = *contexts[ndx];
585 const deUint32 program = programs[ndx];
586
587 setupAttributes(ctx, vertexData, program);
588
589 ctx.disable (GL_SCISSOR_TEST);
590 ctx.colorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
591 ctx.depthMask (GL_TRUE);
592 ctx.stencilMask (~0u);
593 ctx.clearColor (clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
594 ctx.clear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
595
596 ctx.useProgram (program);
597
598 for (vector<rsg::VariableValue>::const_iterator uniformIter = uniformValues.begin(); uniformIter != uniformValues.end(); ++uniformIter)
599 setUniformValue(ctx, ctx.getUniformLocation(program, uniformIter->getVariable()->getName()), uniformIter->getValue());
600
601 for (vector<RenderCommand>::const_iterator cmdIter = renderCmds.begin(); cmdIter != renderCmds.end(); ++cmdIter)
602 render(ctx, posPtr, *cmdIter);
603
604 GLU_EXPECT_NO_ERROR(ctx.getError(), "Rendering failed");
605
606 ctx.readPixels(0, 0, m_viewportSize.x(), m_viewportSize.y(), GL_RGBA, GL_UNSIGNED_BYTE, readDst[ndx].getDataPtr());
607 }
608 }
609
610 {
611 const tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold()+tcu::RGBA(3,3,3,3);
612 const bool compareOk = tcu::bilinearCompare(m_testCtx.getLog(), "CompareResult", "Image comparison result", reference.getAccess(), rendered.getAccess(), threshold, tcu::COMPARE_LOG_RESULT);
613
614 if (!compareOk)
615 {
616 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
617 return STOP;
618 }
619 }
620
621 m_iterNdx += 1;
622 return (m_iterNdx < NUM_ITERATIONS) ? CONTINUE : STOP;
623 }
624
625 } // gls
626 } // deqp
627