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