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 Shadow texture lookup tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fTextureShadowTests.hpp"
25 #include "gluTexture.hpp"
26 #include "gluPixelTransfer.hpp"
27 #include "gluTextureUtil.hpp"
28 #include "glsTextureTestUtil.hpp"
29 #include "tcuTextureUtil.hpp"
30 #include "tcuRenderTarget.hpp"
31 #include "tcuTexCompareVerifier.hpp"
32 #include "deString.h"
33 #include "deMath.h"
34 #include "deStringUtil.hpp"
35 #include "glwFunctions.hpp"
36 #include "glwEnums.hpp"
37
38 namespace deqp
39 {
40 namespace gles3
41 {
42 namespace Functional
43 {
44
45 using std::vector;
46 using std::string;
47 using tcu::TestLog;
48 using namespace deqp::gls::TextureTestUtil;
49 using namespace glu::TextureTestUtil;
50
51 enum
52 {
53 TEX2D_VIEWPORT_WIDTH = 64,
54 TEX2D_VIEWPORT_HEIGHT = 64,
55 TEX2D_MIN_VIEWPORT_WIDTH = 64,
56 TEX2D_MIN_VIEWPORT_HEIGHT = 64
57 };
58
isFloatingPointDepthFormat(const tcu::TextureFormat & format)59 static bool isFloatingPointDepthFormat (const tcu::TextureFormat& format)
60 {
61 // Only two depth and depth-stencil formats are floating point
62 return (format.order == tcu::TextureFormat::D && format.type == tcu::TextureFormat::FLOAT) ||
63 (format.order == tcu::TextureFormat::DS && format.type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV);
64 }
65
clampFloatingPointTexture(const tcu::PixelBufferAccess & access)66 static void clampFloatingPointTexture (const tcu::PixelBufferAccess& access)
67 {
68 DE_ASSERT(isFloatingPointDepthFormat(access.getFormat()));
69
70 for (int z = 0; z < access.getDepth(); ++z)
71 for (int y = 0; y < access.getHeight(); ++y)
72 for (int x = 0; x < access.getWidth(); ++x)
73 access.setPixDepth( de::clamp(access.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z);
74 }
75
clampFloatingPointTexture(tcu::Texture2D & target)76 static void clampFloatingPointTexture (tcu::Texture2D& target)
77 {
78 for (int level = 0; level < target.getNumLevels(); ++level)
79 if (!target.isLevelEmpty(level))
80 clampFloatingPointTexture(target.getLevel(level));
81 }
82
clampFloatingPointTexture(tcu::Texture2DArray & target)83 static void clampFloatingPointTexture (tcu::Texture2DArray& target)
84 {
85 for (int level = 0; level < target.getNumLevels(); ++level)
86 if (!target.isLevelEmpty(level))
87 clampFloatingPointTexture(target.getLevel(level));
88 }
89
clampFloatingPointTexture(tcu::TextureCube & target)90 static void clampFloatingPointTexture (tcu::TextureCube& target)
91 {
92 for (int level = 0; level < target.getNumLevels(); ++level)
93 for (int face = tcu::CUBEFACE_NEGATIVE_X; face < tcu::CUBEFACE_LAST; ++face)
94 clampFloatingPointTexture(target.getLevelFace(level, (tcu::CubeFace)face));
95 }
96
97 template<typename TextureType>
verifyTexCompareResult(tcu::TestContext & testCtx,const tcu::ConstPixelBufferAccess & result,const TextureType & src,const float * texCoord,const ReferenceParams & sampleParams,const tcu::TexComparePrecision & comparePrec,const tcu::LodPrecision & lodPrec,const tcu::PixelFormat & pixelFormat)98 bool verifyTexCompareResult (tcu::TestContext& testCtx,
99 const tcu::ConstPixelBufferAccess& result,
100 const TextureType& src,
101 const float* texCoord,
102 const ReferenceParams& sampleParams,
103 const tcu::TexComparePrecision& comparePrec,
104 const tcu::LodPrecision& lodPrec,
105 const tcu::PixelFormat& pixelFormat)
106 {
107 tcu::TestLog& log = testCtx.getLog();
108 tcu::Surface reference (result.getWidth(), result.getHeight());
109 tcu::Surface errorMask (result.getWidth(), result.getHeight());
110 const tcu::Vec3 nonShadowThreshold = tcu::computeFixedPointThreshold(getBitsVec(pixelFormat)-1).swizzle(1,2,3);
111 int numFailedPixels;
112
113 // sampleTexture() expects source image to be the same state as it would be in a GL implementation, that is
114 // the floating point depth values should be in [0, 1] range as data is clamped during texture upload. Since
115 // we don't have a separate "uploading" phase and just reuse the buffer we used for GL-upload, do the clamping
116 // here if necessary.
117
118 if (isFloatingPointDepthFormat(src.getFormat()))
119 {
120 TextureType clampedSource(src);
121
122 clampFloatingPointTexture(clampedSource);
123
124 // sample clamped values
125
126 sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), clampedSource, texCoord, sampleParams);
127 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), clampedSource, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold);
128 }
129 else
130 {
131 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values)
132
133 sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), src, texCoord, sampleParams);
134 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), src, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold);
135 }
136
137 if (numFailedPixels > 0)
138 log << TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << TestLog::EndMessage;
139
140 log << TestLog::ImageSet("VerifyResult", "Verification result")
141 << TestLog::Image("Rendered", "Rendered image", result);
142
143 if (numFailedPixels > 0)
144 {
145 log << TestLog::Image("Reference", "Ideal reference image", reference)
146 << TestLog::Image("ErrorMask", "Error mask", errorMask);
147 }
148
149 log << TestLog::EndImageSet;
150
151 return numFailedPixels == 0;
152 }
153
154 class Texture2DShadowCase : public TestCase
155 {
156 public:
157 Texture2DShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc);
158 ~Texture2DShadowCase (void);
159
160 void init (void);
161 void deinit (void);
162 IterateResult iterate (void);
163
164 private:
165 Texture2DShadowCase (const Texture2DShadowCase& other);
166 Texture2DShadowCase& operator= (const Texture2DShadowCase& other);
167
168 const deUint32 m_minFilter;
169 const deUint32 m_magFilter;
170 const deUint32 m_wrapS;
171 const deUint32 m_wrapT;
172 const deUint32 m_format;
173 const int m_width;
174 const int m_height;
175 const deUint32 m_compareFunc;
176
177 struct FilterCase
178 {
179 const glu::Texture2D* texture;
180 tcu::Vec2 minCoord;
181 tcu::Vec2 maxCoord;
182 float ref;
183
FilterCasedeqp::gles3::Functional::Texture2DShadowCase::FilterCase184 FilterCase (void)
185 : texture (DE_NULL)
186 , ref (0.0f)
187 {
188 }
189
FilterCasedeqp::gles3::Functional::Texture2DShadowCase::FilterCase190 FilterCase (const glu::Texture2D* tex_, const float ref_, const tcu::Vec2& minCoord_, const tcu::Vec2& maxCoord_)
191 : texture (tex_)
192 , minCoord (minCoord_)
193 , maxCoord (maxCoord_)
194 , ref (ref_)
195 {
196 }
197 };
198
199 std::vector<glu::Texture2D*> m_textures;
200 std::vector<FilterCase> m_cases;
201
202 TextureRenderer m_renderer;
203
204 int m_caseNdx;
205 };
206
Texture2DShadowCase(Context & context,const char * name,const char * desc,deUint32 minFilter,deUint32 magFilter,deUint32 wrapS,deUint32 wrapT,deUint32 format,int width,int height,deUint32 compareFunc)207 Texture2DShadowCase::Texture2DShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc)
208 : TestCase (context, name, desc)
209 , m_minFilter (minFilter)
210 , m_magFilter (magFilter)
211 , m_wrapS (wrapS)
212 , m_wrapT (wrapT)
213 , m_format (format)
214 , m_width (width)
215 , m_height (height)
216 , m_compareFunc (compareFunc)
217 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
218 , m_caseNdx (0)
219 {
220 }
221
~Texture2DShadowCase(void)222 Texture2DShadowCase::~Texture2DShadowCase (void)
223 {
224 deinit();
225 }
226
init(void)227 void Texture2DShadowCase::init (void)
228 {
229 try
230 {
231 // Create 2 textures.
232 m_textures.reserve(2);
233 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height));
234 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height));
235
236 int numLevels = m_textures[0]->getRefTexture().getNumLevels();
237
238 // Fill first gradient texture.
239 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
240 {
241 m_textures[0]->getRefTexture().allocLevel(levelNdx);
242 tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f));
243 }
244
245 // Fill second with grid texture.
246 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
247 {
248 deUint32 step = 0x00ffffff / numLevels;
249 deUint32 rgb = step*levelNdx;
250 deUint32 colorA = 0xff000000 | rgb;
251 deUint32 colorB = 0xff000000 | ~rgb;
252
253 m_textures[1]->getRefTexture().allocLevel(levelNdx);
254 tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec(), tcu::RGBA(colorB).toVec());
255 }
256
257 // Upload.
258 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
259 (*i)->upload();
260 }
261 catch (const std::exception&)
262 {
263 // Clean up to save memory.
264 Texture2DShadowCase::deinit();
265 throw;
266 }
267
268 // Compute cases.
269 {
270 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
271 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
272 const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range
273 const float refOutOfBoundsLower = -0.1f;
274
275 const struct
276 {
277 int texNdx;
278 float ref;
279 float lodX;
280 float lodY;
281 float oX;
282 float oY;
283 } cases[] =
284 {
285 { 0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f },
286 { 0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f },
287 { 1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f },
288 { 1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f },
289 { 1, refOutOfBoundsUpper, -0.39f, -0.52f, 0.65f, 0.87f },
290 { 1, refOutOfBoundsLower, -1.55f, 0.65f, 0.35f, 0.91f },
291 };
292
293 const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth());
294 const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight());
295
296 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
297 {
298 const int texNdx = de::clamp(cases[caseNdx].texNdx, 0, (int)m_textures.size()-1);
299 const float ref = cases[caseNdx].ref;
300 const float lodX = cases[caseNdx].lodX;
301 const float lodY = cases[caseNdx].lodY;
302 const float oX = cases[caseNdx].oX;
303 const float oY = cases[caseNdx].oY;
304 const float sX = deFloatExp2(lodX)*viewportW / float(m_textures[texNdx]->getRefTexture().getWidth());
305 const float sY = deFloatExp2(lodY)*viewportH / float(m_textures[texNdx]->getRefTexture().getHeight());
306
307 m_cases.push_back(FilterCase(m_textures[texNdx], ref, tcu::Vec2(oX, oY), tcu::Vec2(oX+sX, oY+sY)));
308 }
309 }
310
311 m_caseNdx = 0;
312 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
313 }
314
deinit(void)315 void Texture2DShadowCase::deinit (void)
316 {
317 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
318 delete *i;
319 m_textures.clear();
320
321 m_renderer.clear();
322 m_cases.clear();
323 }
324
iterate(void)325 Texture2DShadowCase::IterateResult Texture2DShadowCase::iterate (void)
326 {
327 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
328 const RandomViewport viewport (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
329 const FilterCase& curCase = m_cases[m_caseNdx];
330 const tcu::ScopedLogSection section (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
331 ReferenceParams sampleParams (TEXTURETYPE_2D);
332 tcu::Surface rendered (viewport.width, viewport.height);
333 vector<float> texCoord;
334
335 if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT)
336 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__);
337
338 // Setup params for reference.
339 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter);
340 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc);
341 sampleParams.samplerType = SAMPLERTYPE_SHADOW;
342 sampleParams.lodMode = LODMODE_EXACT;
343 sampleParams.ref = curCase.ref;
344
345 m_testCtx.getLog() << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;
346
347 // Compute texture coordinates.
348 m_testCtx.getLog() << TestLog::Message << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord << TestLog::EndMessage;
349 computeQuadTexCoord2D(texCoord, curCase.minCoord, curCase.maxCoord);
350
351 gl.bindTexture (GL_TEXTURE_2D, curCase.texture->getGLTexture());
352 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter);
353 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter);
354 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS);
355 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT);
356 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
357 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, m_compareFunc);
358
359 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
360 m_renderer.renderQuad(0, &texCoord[0], sampleParams);
361 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess());
362
363 {
364 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();
365 tcu::LodPrecision lodPrecision;
366 tcu::TexComparePrecision texComparePrecision;
367
368 lodPrecision.derivateBits = 18;
369 lodPrecision.lodBits = 6;
370 texComparePrecision.coordBits = tcu::IVec3(20,20,0);
371 texComparePrecision.uvwBits = tcu::IVec3(7,7,0);
372 texComparePrecision.pcfBits = 5;
373 texComparePrecision.referenceBits = 16;
374 texComparePrecision.resultBits = pixelFormat.redBits-1;
375
376 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
377 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
378
379 if (!isHighQuality)
380 {
381 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
382
383 lodPrecision.lodBits = 4;
384 texComparePrecision.uvwBits = tcu::IVec3(4,4,0);
385 texComparePrecision.pcfBits = 0;
386
387 const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
388 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
389
390 if (!isOk)
391 {
392 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
393 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
394 }
395 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
396 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
397 }
398 }
399
400 m_caseNdx += 1;
401 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
402 }
403
404 class TextureCubeShadowCase : public TestCase
405 {
406 public:
407 TextureCubeShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc);
408 ~TextureCubeShadowCase (void);
409
410 void init (void);
411 void deinit (void);
412 IterateResult iterate (void);
413
414 private:
415 TextureCubeShadowCase (const TextureCubeShadowCase& other);
416 TextureCubeShadowCase& operator= (const TextureCubeShadowCase& other);
417
418 const deUint32 m_minFilter;
419 const deUint32 m_magFilter;
420 const deUint32 m_wrapS;
421 const deUint32 m_wrapT;
422
423 const deUint32 m_format;
424 const int m_size;
425
426 const deUint32 m_compareFunc;
427
428 struct FilterCase
429 {
430 const glu::TextureCube* texture;
431 tcu::Vec2 bottomLeft;
432 tcu::Vec2 topRight;
433 float ref;
434
FilterCasedeqp::gles3::Functional::TextureCubeShadowCase::FilterCase435 FilterCase (void)
436 : texture (DE_NULL)
437 , ref (0.0f)
438 {
439 }
440
FilterCasedeqp::gles3::Functional::TextureCubeShadowCase::FilterCase441 FilterCase (const glu::TextureCube* tex_, const float ref_, const tcu::Vec2& bottomLeft_, const tcu::Vec2& topRight_)
442 : texture (tex_)
443 , bottomLeft(bottomLeft_)
444 , topRight (topRight_)
445 , ref (ref_)
446 {
447 }
448 };
449
450 glu::TextureCube* m_gradientTex;
451 glu::TextureCube* m_gridTex;
452 std::vector<FilterCase> m_cases;
453
454 TextureRenderer m_renderer;
455
456 int m_caseNdx;
457 };
458
TextureCubeShadowCase(Context & context,const char * name,const char * desc,deUint32 minFilter,deUint32 magFilter,deUint32 wrapS,deUint32 wrapT,deUint32 format,int size,deUint32 compareFunc)459 TextureCubeShadowCase::TextureCubeShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc)
460 : TestCase (context, name, desc)
461 , m_minFilter (minFilter)
462 , m_magFilter (magFilter)
463 , m_wrapS (wrapS)
464 , m_wrapT (wrapT)
465 , m_format (format)
466 , m_size (size)
467 , m_compareFunc (compareFunc)
468 , m_gradientTex (DE_NULL)
469 , m_gridTex (DE_NULL)
470 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
471 , m_caseNdx (0)
472 {
473 }
474
~TextureCubeShadowCase(void)475 TextureCubeShadowCase::~TextureCubeShadowCase (void)
476 {
477 TextureCubeShadowCase::deinit();
478 }
479
init(void)480 void TextureCubeShadowCase::init (void)
481 {
482 try
483 {
484 DE_ASSERT(!m_gradientTex && !m_gridTex);
485
486 int numLevels = deLog2Floor32(m_size)+1;
487 tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format);
488 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
489 tcu::Vec4 cBias = fmtInfo.valueMin;
490 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin;
491
492 // Create textures.
493 m_gradientTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size);
494 m_gridTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size);
495
496 // Fill first with gradient texture.
497 static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] =
498 {
499 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative x
500 { tcu::Vec4( 0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive x
501 { tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative y
502 { tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive y
503 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, // negative z
504 { tcu::Vec4( 0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) } // positive z
505 };
506 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
507 {
508 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
509 {
510 m_gradientTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx);
511 tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), gradients[face][0]*cScale + cBias, gradients[face][1]*cScale + cBias);
512 }
513 }
514
515 // Fill second with grid texture.
516 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
517 {
518 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
519 {
520 deUint32 step = 0x00ffffff / (numLevels*tcu::CUBEFACE_LAST);
521 deUint32 rgb = step*levelNdx*face;
522 deUint32 colorA = 0xff000000 | rgb;
523 deUint32 colorB = 0xff000000 | ~rgb;
524
525 m_gridTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx);
526 tcu::fillWithGrid(m_gridTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias);
527 }
528 }
529
530 // Upload.
531 m_gradientTex->upload();
532 m_gridTex->upload();
533 }
534 catch (const std::exception&)
535 {
536 // Clean up to save memory.
537 TextureCubeShadowCase::deinit();
538 throw;
539 }
540
541 // Compute cases
542 {
543 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
544 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
545 const float refOutOfBoundsUpper = 1.1f;
546 const float refOutOfBoundsLower = -0.1f;
547 const bool singleSample = m_context.getRenderTarget().getNumSamples() == 0;
548
549 if (singleSample)
550 m_cases.push_back(FilterCase(m_gradientTex, refInRangeUpper, tcu::Vec2(-1.25f, -1.2f), tcu::Vec2(1.2f, 1.25f))); // minification
551 else
552 m_cases.push_back(FilterCase(m_gradientTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f))); // minification - w/ tuned coordinates to avoid hitting triangle edges
553
554 m_cases.push_back(FilterCase(m_gradientTex, refInRangeLower, tcu::Vec2(0.8f, 0.8f), tcu::Vec2(1.25f, 1.20f))); // magnification
555 m_cases.push_back(FilterCase(m_gridTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f))); // minification
556 m_cases.push_back(FilterCase(m_gridTex, refInRangeLower, tcu::Vec2(-1.2f, -1.1f), tcu::Vec2(-0.8f, -0.8f))); // magnification
557 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsUpper, tcu::Vec2(-0.61f, -0.1f), tcu::Vec2(0.9f, 1.18f))); // reference value clamp, upper
558
559 if (singleSample)
560 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.05f, 0.75f))); // reference value clamp, lower
561 else
562 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.25f, 0.75f))); // reference value clamp, lower
563 }
564
565 m_caseNdx = 0;
566 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
567 }
568
deinit(void)569 void TextureCubeShadowCase::deinit (void)
570 {
571 delete m_gradientTex;
572 delete m_gridTex;
573
574 m_gradientTex = DE_NULL;
575 m_gridTex = DE_NULL;
576
577 m_renderer.clear();
578 m_cases.clear();
579 }
580
getFaceDesc(const tcu::CubeFace face)581 static const char* getFaceDesc (const tcu::CubeFace face)
582 {
583 switch (face)
584 {
585 case tcu::CUBEFACE_NEGATIVE_X: return "-X";
586 case tcu::CUBEFACE_POSITIVE_X: return "+X";
587 case tcu::CUBEFACE_NEGATIVE_Y: return "-Y";
588 case tcu::CUBEFACE_POSITIVE_Y: return "+Y";
589 case tcu::CUBEFACE_NEGATIVE_Z: return "-Z";
590 case tcu::CUBEFACE_POSITIVE_Z: return "+Z";
591 default:
592 DE_ASSERT(false);
593 return DE_NULL;
594 }
595 }
596
iterate(void)597 TextureCubeShadowCase::IterateResult TextureCubeShadowCase::iterate (void)
598 {
599 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
600 const int viewportSize = 28;
601 const RandomViewport viewport (m_context.getRenderTarget(), viewportSize, viewportSize, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
602 const tcu::ScopedLogSection iterSection (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
603 const FilterCase& curCase = m_cases[m_caseNdx];
604 ReferenceParams sampleParams (TEXTURETYPE_CUBE);
605
606 if (viewport.width < viewportSize || viewport.height < viewportSize)
607 throw tcu::NotSupportedError("Too small render target", DE_NULL, __FILE__, __LINE__);
608
609 // Setup texture
610 gl.bindTexture (GL_TEXTURE_CUBE_MAP, curCase.texture->getGLTexture());
611 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter);
612 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter);
613 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS);
614 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT);
615 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
616 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_FUNC, m_compareFunc);
617
618 // Other state
619 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
620
621 // Params for reference computation.
622 sampleParams.sampler = glu::mapGLSampler(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, m_minFilter, m_magFilter);
623 sampleParams.sampler.seamlessCubeMap = true;
624 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc);
625 sampleParams.samplerType = SAMPLERTYPE_SHADOW;
626 sampleParams.lodMode = LODMODE_EXACT;
627 sampleParams.ref = curCase.ref;
628
629 m_testCtx.getLog()
630 << TestLog::Message
631 << "Compare reference value = " << sampleParams.ref << "\n"
632 << "Coordinates: " << curCase.bottomLeft << " -> " << curCase.topRight
633 << TestLog::EndMessage;
634
635 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
636 {
637 const tcu::CubeFace face = tcu::CubeFace(faceNdx);
638 tcu::Surface result (viewport.width, viewport.height);
639 vector<float> texCoord;
640
641 computeQuadTexCoordCube(texCoord, face, curCase.bottomLeft, curCase.topRight);
642
643 m_testCtx.getLog() << TestLog::Message << "Face " << getFaceDesc(face) << TestLog::EndMessage;
644
645 // \todo Log texture coordinates.
646
647 m_renderer.renderQuad(0, &texCoord[0], sampleParams);
648 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
649
650 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, result.getAccess());
651 GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
652
653 {
654 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();
655 tcu::LodPrecision lodPrecision;
656 tcu::TexComparePrecision texComparePrecision;
657
658 lodPrecision.derivateBits = 10;
659 lodPrecision.lodBits = 5;
660 texComparePrecision.coordBits = tcu::IVec3(10,10,10);
661 texComparePrecision.uvwBits = tcu::IVec3(6,6,0);
662 texComparePrecision.pcfBits = 5;
663 texComparePrecision.referenceBits = 16;
664 texComparePrecision.resultBits = pixelFormat.redBits-1;
665
666 const bool isHighQuality = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(),
667 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
668
669 if (!isHighQuality)
670 {
671 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
672
673 lodPrecision.lodBits = 4;
674 texComparePrecision.uvwBits = tcu::IVec3(4,4,0);
675 texComparePrecision.pcfBits = 0;
676
677 const bool isOk = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(),
678 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
679
680 if (!isOk)
681 {
682 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
683 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
684 }
685 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
686 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
687 }
688 }
689 }
690
691 m_caseNdx += 1;
692 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
693 }
694
695 class Texture2DArrayShadowCase : public TestCase
696 {
697 public:
698 Texture2DArrayShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc);
699 ~Texture2DArrayShadowCase (void);
700
701 void init (void);
702 void deinit (void);
703 IterateResult iterate (void);
704
705 private:
706 Texture2DArrayShadowCase (const Texture2DArrayShadowCase& other);
707 Texture2DArrayShadowCase& operator= (const Texture2DArrayShadowCase& other);
708
709 const deUint32 m_minFilter;
710 const deUint32 m_magFilter;
711 const deUint32 m_wrapS;
712 const deUint32 m_wrapT;
713
714 const deUint32 m_format;
715 const int m_width;
716 const int m_height;
717 const int m_numLayers;
718
719 const deUint32 m_compareFunc;
720
721 struct FilterCase
722 {
723 const glu::Texture2DArray* texture;
724 tcu::Vec3 minCoord;
725 tcu::Vec3 maxCoord;
726 float ref;
727
FilterCasedeqp::gles3::Functional::Texture2DArrayShadowCase::FilterCase728 FilterCase (void)
729 : texture (DE_NULL)
730 , ref (0.0f)
731 {
732 }
733
FilterCasedeqp::gles3::Functional::Texture2DArrayShadowCase::FilterCase734 FilterCase (const glu::Texture2DArray* tex_, float ref_, const tcu::Vec3& minCoord_, const tcu::Vec3& maxCoord_)
735 : texture (tex_)
736 , minCoord (minCoord_)
737 , maxCoord (maxCoord_)
738 , ref (ref_)
739 {
740 }
741 };
742
743 glu::Texture2DArray* m_gradientTex;
744 glu::Texture2DArray* m_gridTex;
745 std::vector<FilterCase> m_cases;
746
747 TextureRenderer m_renderer;
748
749 int m_caseNdx;
750 };
751
Texture2DArrayShadowCase(Context & context,const char * name,const char * desc,deUint32 minFilter,deUint32 magFilter,deUint32 wrapS,deUint32 wrapT,deUint32 format,int width,int height,int numLayers,deUint32 compareFunc)752 Texture2DArrayShadowCase::Texture2DArrayShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc)
753 : TestCase (context, name, desc)
754 , m_minFilter (minFilter)
755 , m_magFilter (magFilter)
756 , m_wrapS (wrapS)
757 , m_wrapT (wrapT)
758 , m_format (format)
759 , m_width (width)
760 , m_height (height)
761 , m_numLayers (numLayers)
762 , m_compareFunc (compareFunc)
763 , m_gradientTex (DE_NULL)
764 , m_gridTex (DE_NULL)
765 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
766 , m_caseNdx (0)
767 {
768 }
769
~Texture2DArrayShadowCase(void)770 Texture2DArrayShadowCase::~Texture2DArrayShadowCase (void)
771 {
772 Texture2DArrayShadowCase::deinit();
773 }
774
init(void)775 void Texture2DArrayShadowCase::init (void)
776 {
777 try
778 {
779 tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format);
780 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
781 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin;
782 tcu::Vec4 cBias = fmtInfo.valueMin;
783 int numLevels = deLog2Floor32(de::max(m_width, m_height)) + 1;
784
785 // Create textures.
786 m_gradientTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers);
787 m_gridTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers);
788
789 // Fill first gradient texture.
790 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
791 {
792 tcu::Vec4 gMin = tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f)*cScale + cBias;
793 tcu::Vec4 gMax = tcu::Vec4( 1.0f, 1.0f, 1.0f, 0.0f)*cScale + cBias;
794
795 m_gradientTex->getRefTexture().allocLevel(levelNdx);
796 tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevel(levelNdx), gMin, gMax);
797 }
798
799 // Fill second with grid texture.
800 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
801 {
802 deUint32 step = 0x00ffffff / numLevels;
803 deUint32 rgb = step*levelNdx;
804 deUint32 colorA = 0xff000000 | rgb;
805 deUint32 colorB = 0xff000000 | ~rgb;
806
807 m_gridTex->getRefTexture().allocLevel(levelNdx);
808 tcu::fillWithGrid(m_gridTex->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias);
809 }
810
811 // Upload.
812 m_gradientTex->upload();
813 m_gridTex->upload();
814 }
815 catch (...)
816 {
817 // Clean up to save memory.
818 Texture2DArrayShadowCase::deinit();
819 throw;
820 }
821
822 // Compute cases.
823 {
824 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
825 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
826 const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range
827 const float refOutOfBoundsLower = -0.1f;
828
829 const struct
830 {
831 int texNdx;
832 float ref;
833 float lodX;
834 float lodY;
835 float oX;
836 float oY;
837 } cases[] =
838 {
839 { 0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f },
840 { 0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f },
841 { 1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f },
842 { 1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f },
843 { 1, refOutOfBoundsUpper, -0.49f, -0.22f, 0.45f, 0.97f },
844 { 1, refOutOfBoundsLower, -0.85f, 0.75f, 0.25f, 0.61f },
845 };
846
847 const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth());
848 const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight());
849
850 const float minLayer = -0.5f;
851 const float maxLayer = (float)m_numLayers;
852
853 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
854 {
855 const glu::Texture2DArray* tex = cases[caseNdx].texNdx > 0 ? m_gridTex : m_gradientTex;
856 const float ref = cases[caseNdx].ref;
857 const float lodX = cases[caseNdx].lodX;
858 const float lodY = cases[caseNdx].lodY;
859 const float oX = cases[caseNdx].oX;
860 const float oY = cases[caseNdx].oY;
861 const float sX = deFloatExp2(lodX)*viewportW / float(tex->getRefTexture().getWidth());
862 const float sY = deFloatExp2(lodY)*viewportH / float(tex->getRefTexture().getHeight());
863
864 m_cases.push_back(FilterCase(tex, ref, tcu::Vec3(oX, oY, minLayer), tcu::Vec3(oX+sX, oY+sY, maxLayer)));
865 }
866 }
867
868 m_caseNdx = 0;
869 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
870 }
871
deinit(void)872 void Texture2DArrayShadowCase::deinit (void)
873 {
874 delete m_gradientTex;
875 delete m_gridTex;
876
877 m_gradientTex = DE_NULL;
878 m_gridTex = DE_NULL;
879
880 m_renderer.clear();
881 m_cases.clear();
882 }
883
iterate(void)884 Texture2DArrayShadowCase::IterateResult Texture2DArrayShadowCase::iterate (void)
885 {
886 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
887 const RandomViewport viewport (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
888 const FilterCase& curCase = m_cases[m_caseNdx];
889 const tcu::ScopedLogSection section (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
890 ReferenceParams sampleParams (TEXTURETYPE_2D_ARRAY);
891 tcu::Surface rendered (viewport.width, viewport.height);
892
893 const float texCoord[] =
894 {
895 curCase.minCoord.x(), curCase.minCoord.y(), curCase.minCoord.z(),
896 curCase.minCoord.x(), curCase.maxCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f,
897 curCase.maxCoord.x(), curCase.minCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f,
898 curCase.maxCoord.x(), curCase.maxCoord.y(), curCase.maxCoord.z()
899 };
900
901 if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT)
902 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__);
903
904 // Setup params for reference.
905 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter);
906 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc);
907 sampleParams.samplerType = SAMPLERTYPE_SHADOW;
908 sampleParams.lodMode = LODMODE_EXACT;
909 sampleParams.ref = curCase.ref;
910
911 m_testCtx.getLog()
912 << TestLog::Message
913 << "Compare reference value = " << sampleParams.ref << "\n"
914 << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord
915 << TestLog::EndMessage;
916
917 gl.bindTexture (GL_TEXTURE_2D_ARRAY, curCase.texture->getGLTexture());
918 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, m_minFilter);
919 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, m_magFilter);
920 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, m_wrapS);
921 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, m_wrapT);
922 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
923 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, m_compareFunc);
924
925 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
926 m_renderer.renderQuad(0, &texCoord[0], sampleParams);
927 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess());
928
929 {
930 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();
931 tcu::LodPrecision lodPrecision;
932 tcu::TexComparePrecision texComparePrecision;
933
934 lodPrecision.derivateBits = 18;
935 lodPrecision.lodBits = 6;
936 texComparePrecision.coordBits = tcu::IVec3(20,20,20);
937 texComparePrecision.uvwBits = tcu::IVec3(7,7,7);
938 texComparePrecision.pcfBits = 5;
939 texComparePrecision.referenceBits = 16;
940 texComparePrecision.resultBits = pixelFormat.redBits-1;
941
942 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
943 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
944
945 if (!isHighQuality)
946 {
947 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
948
949 lodPrecision.lodBits = 4;
950 texComparePrecision.uvwBits = tcu::IVec3(4,4,4);
951 texComparePrecision.pcfBits = 0;
952
953 const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
954 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
955
956 if (!isOk)
957 {
958 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
959 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
960 }
961 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
962 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
963 }
964 }
965
966 m_caseNdx += 1;
967 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
968 }
969
TextureShadowTests(Context & context)970 TextureShadowTests::TextureShadowTests (Context& context)
971 : TestCaseGroup(context, "shadow", "Shadow texture lookup tests")
972 {
973 }
974
~TextureShadowTests(void)975 TextureShadowTests::~TextureShadowTests (void)
976 {
977 }
978
init(void)979 void TextureShadowTests::init (void)
980 {
981 static const struct
982 {
983 const char* name;
984 deUint32 format;
985 } formats[] =
986 {
987 { "depth_component16", GL_DEPTH_COMPONENT16 },
988 { "depth_component32f", GL_DEPTH_COMPONENT32F },
989 { "depth24_stencil8", GL_DEPTH24_STENCIL8 }
990 };
991
992 static const struct
993 {
994 const char* name;
995 deUint32 minFilter;
996 deUint32 magFilter;
997 } filters[] =
998 {
999 { "nearest", GL_NEAREST, GL_NEAREST },
1000 { "linear", GL_LINEAR, GL_LINEAR },
1001 { "nearest_mipmap_nearest", GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR },
1002 { "linear_mipmap_nearest", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR },
1003 { "nearest_mipmap_linear", GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR },
1004 { "linear_mipmap_linear", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR }
1005 };
1006
1007 static const struct
1008 {
1009 const char* name;
1010 deUint32 func;
1011 } compareFuncs[] =
1012 {
1013 { "less_or_equal", GL_LEQUAL },
1014 { "greater_or_equal", GL_GEQUAL },
1015 { "less", GL_LESS },
1016 { "greater", GL_GREATER },
1017 { "equal", GL_EQUAL },
1018 { "not_equal", GL_NOTEQUAL },
1019 { "always", GL_ALWAYS },
1020 { "never", GL_NEVER }
1021 };
1022
1023 // 2D cases.
1024 {
1025 tcu::TestCaseGroup* group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D texture shadow lookup tests");
1026 addChild(group2D);
1027
1028 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1029 {
1030 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1031 group2D->addChild(filterGroup);
1032
1033 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1034 {
1035 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1036 {
1037 deUint32 minFilter = filters[filterNdx].minFilter;
1038 deUint32 magFilter = filters[filterNdx].magFilter;
1039 deUint32 format = formats[formatNdx].format;
1040 deUint32 compareFunc = compareFuncs[compareNdx].func;
1041 const deUint32 wrapS = GL_REPEAT;
1042 const deUint32 wrapT = GL_REPEAT;
1043 const int width = 32;
1044 const int height = 64;
1045 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1046
1047 filterGroup->addChild(new Texture2DShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc));
1048 }
1049 }
1050 }
1051 }
1052
1053 // Cubemap cases.
1054 {
1055 tcu::TestCaseGroup* groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube map texture shadow lookup tests");
1056 addChild(groupCube);
1057
1058 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1059 {
1060 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1061 groupCube->addChild(filterGroup);
1062
1063 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1064 {
1065 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1066 {
1067 deUint32 minFilter = filters[filterNdx].minFilter;
1068 deUint32 magFilter = filters[filterNdx].magFilter;
1069 deUint32 format = formats[formatNdx].format;
1070 deUint32 compareFunc = compareFuncs[compareNdx].func;
1071 const deUint32 wrapS = GL_REPEAT;
1072 const deUint32 wrapT = GL_REPEAT;
1073 const int size = 32;
1074 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1075
1076 filterGroup->addChild(new TextureCubeShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, size, compareFunc));
1077 }
1078 }
1079 }
1080 }
1081
1082 // 2D array cases.
1083 {
1084 tcu::TestCaseGroup* group2DArray = new tcu::TestCaseGroup(m_testCtx, "2d_array", "2D texture array shadow lookup tests");
1085 addChild(group2DArray);
1086
1087 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1088 {
1089 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1090 group2DArray->addChild(filterGroup);
1091
1092 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1093 {
1094 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1095 {
1096 deUint32 minFilter = filters[filterNdx].minFilter;
1097 deUint32 magFilter = filters[filterNdx].magFilter;
1098 deUint32 format = formats[formatNdx].format;
1099 deUint32 compareFunc = compareFuncs[compareNdx].func;
1100 const deUint32 wrapS = GL_REPEAT;
1101 const deUint32 wrapT = GL_REPEAT;
1102 const int width = 32;
1103 const int height = 64;
1104 const int numLayers = 8;
1105 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1106
1107 filterGroup->addChild(new Texture2DArrayShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc));
1108 }
1109 }
1110 }
1111 }
1112 }
1113
1114 } // Functional
1115 } // gles3
1116 } // deqp
1117