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 Framebuffer completeness tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fFboCompletenessTests.hpp"
25
26 #include "glsFboCompletenessTests.hpp"
27 #include <sstream>
28
29 using namespace glw;
30 using deqp::gls::Range;
31 using namespace deqp::gls::FboUtil;
32 using namespace deqp::gls::FboUtil::config;
33 namespace fboc = deqp::gls::fboc;
34 typedef tcu::TestCase::IterateResult IterateResult;
35 using std::string;
36 using std::ostringstream;
37
38 namespace deqp
39 {
40 namespace gles3
41 {
42 namespace Functional
43 {
44
45 static const FormatKey s_es3ColorRenderables[] =
46 {
47 // GLES3, 4.4.4: "An internal format is color-renderable if it is one of
48 // the formats from table 3.12 noted as color-renderable..."
49 GL_R8, GL_RG8, GL_RGB8, GL_RGB565, GL_RGBA4, GL_RGB5_A1, GL_RGBA8,
50 GL_RGB10_A2, GL_RGB10_A2UI, GL_SRGB8_ALPHA8,
51 GL_R8I, GL_R8UI, GL_R16I, GL_R16UI, GL_R32I, GL_R32UI,
52 GL_RG8I, GL_RG8UI, GL_RG16I, GL_RG16UI, GL_RG32I, GL_RG32UI,
53 GL_RGBA8I, GL_RGBA8UI, GL_RGBA16I, GL_RGBA16UI, GL_RGBA32I, GL_RGBA32UI,
54 };
55
56 static const FormatKey s_es3UnsizedColorRenderables[] =
57 {
58 // "...or if it is unsized format RGBA or RGB."
59 // See Table 3.3 in GLES3.
60 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_BYTE),
61 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4),
62 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1),
63 GLS_UNSIZED_FORMATKEY(GL_RGB, GL_UNSIGNED_BYTE),
64 GLS_UNSIZED_FORMATKEY(GL_RGB, GL_UNSIGNED_SHORT_5_6_5),
65 };
66
67 static const FormatKey s_es3DepthRenderables[] =
68 {
69 // GLES3, 4.4.4: "An internal format is depth-renderable if it is one of
70 // the formats from table 3.13."
71 GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32F,
72 GL_DEPTH24_STENCIL8, GL_DEPTH32F_STENCIL8,
73 };
74
75 static const FormatKey s_es3StencilRboRenderables[] =
76 {
77 // GLES3, 4.4.4: "An internal format is stencil-renderable if it is
78 // STENCIL_INDEX8..."
79 GL_STENCIL_INDEX8,
80 };
81
82 static const FormatKey s_es3StencilRenderables[] =
83 {
84 // "...or one of the formats from table 3.13 whose base internal format is
85 // DEPTH_STENCIL."
86 GL_DEPTH24_STENCIL8, GL_DEPTH32F_STENCIL8,
87 };
88
89 static const FormatKey s_es3TextureFloatFormats[] =
90 {
91 GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F,
92 GL_RG32F, GL_RG16F, GL_R32F, GL_R16F,
93 GL_RGBA16F, GL_RGB16F, GL_RG16F, GL_R16F,
94 };
95
96 static const FormatKey s_es3NotRenderableTextureFormats[] =
97 {
98 GL_R8_SNORM, GL_RG8_SNORM, GL_RGB8_SNORM, GL_RGBA8_SNORM,
99 GL_RGB9_E5, GL_SRGB8,
100 GL_RGB8I, GL_RGB16I, GL_RGB32I,
101 GL_RGB8UI, GL_RGB16UI,GL_RGB32UI,
102 };
103
104 static const FormatEntry s_es3Formats[] =
105 {
106 // Renderbuffers don't support unsized formats
107 { REQUIRED_RENDERABLE | COLOR_RENDERABLE | TEXTURE_VALID,
108 GLS_ARRAY_RANGE(s_es3UnsizedColorRenderables) },
109 { REQUIRED_RENDERABLE | COLOR_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID,
110 GLS_ARRAY_RANGE(s_es3ColorRenderables) },
111 { REQUIRED_RENDERABLE | DEPTH_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID,
112 GLS_ARRAY_RANGE(s_es3DepthRenderables) },
113 { REQUIRED_RENDERABLE | STENCIL_RENDERABLE | RENDERBUFFER_VALID,
114 GLS_ARRAY_RANGE(s_es3StencilRboRenderables) },
115 { REQUIRED_RENDERABLE | STENCIL_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID,
116 GLS_ARRAY_RANGE(s_es3StencilRenderables) },
117 { TEXTURE_VALID,
118 GLS_ARRAY_RANGE(s_es3NotRenderableTextureFormats) },
119
120 // These are not color-renderable in vanilla ES3, but we need to mark them
121 // as valid for textures, since EXT_color_buffer_(half_)float brings in
122 // color-renderability and only renderbuffer-validity.
123 { TEXTURE_VALID,
124 GLS_ARRAY_RANGE(s_es3TextureFloatFormats) },
125 };
126
127 // GL_EXT_color_buffer_float
128 static const FormatKey s_extColorBufferFloatFormats[] =
129 {
130 GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F, GL_RG32F, GL_RG16F, GL_R32F, GL_R16F,
131 };
132
133 // GL_OES_texture_stencil8
134 static const FormatKey s_extOESTextureStencil8[] =
135 {
136 GL_STENCIL_INDEX8,
137 };
138
139 // GL_EXT_render_snorm
140 static const FormatKey s_extRenderSnorm[] =
141 {
142 GL_R8_SNORM, GL_RG8_SNORM, GL_RGBA8_SNORM,
143 };
144
145 static const FormatExtEntry s_es3ExtFormats[] =
146 {
147 {
148 "GL_EXT_color_buffer_float",
149 // These are already texture-valid in ES3, the extension just adds RBO
150 // support and makes them color-renderable.
151 (deUint32)(REQUIRED_RENDERABLE | COLOR_RENDERABLE | RENDERBUFFER_VALID),
152 GLS_ARRAY_RANGE(s_extColorBufferFloatFormats)
153 },
154 {
155 "GL_OES_texture_stencil8",
156 // \note: es3 RBO tests actually cover the first two requirements
157 // - kept here for completeness
158 (deUint32)(REQUIRED_RENDERABLE | STENCIL_RENDERABLE | TEXTURE_VALID),
159 GLS_ARRAY_RANGE(s_extOESTextureStencil8)
160 },
161
162 // Since GLES31 is backwards compatible to GLES3, we might actually be running on a GLES31.
163 // Add rule changes of GLES31 that have no corresponding GLES3 extension.
164 //
165 // \note Not all feature changes are listed here but only those that alter GLES3 subset of
166 // the formats
167 {
168 "DEQP_gles31_core_compatible GL_EXT_render_snorm",
169 (deUint32)(REQUIRED_RENDERABLE | COLOR_RENDERABLE | TEXTURE_VALID | RENDERBUFFER_VALID),
170 GLS_ARRAY_RANGE(s_extRenderSnorm)
171 },
172 };
173
174 class ES3Checker : public Checker
175 {
176 public:
ES3Checker(const glu::RenderContext & ctx)177 ES3Checker (const glu::RenderContext& ctx)
178 : Checker (ctx)
179 , m_numSamples (-1)
180 , m_depthStencilImage (0)
181 , m_depthStencilType (GL_NONE) {}
182 void check (GLenum attPoint, const Attachment& att, const Image* image);
183
184 private:
185 //! The common number of samples of images.
186 GLsizei m_numSamples;
187
188 //! The common image for depth and stencil attachments.
189 GLuint m_depthStencilImage;
190 GLenum m_depthStencilType;
191 };
192
check(GLenum attPoint,const Attachment & att,const Image * image)193 void ES3Checker::check (GLenum attPoint, const Attachment& att, const Image* image)
194 {
195 GLsizei imgSamples = imageNumSamples(*image);
196
197 if (m_numSamples == -1)
198 {
199 m_numSamples = imgSamples;
200 }
201 else
202 {
203 // GLES3: "The value of RENDERBUFFER_SAMPLES is the same for all attached
204 // renderbuffers and, if the attached images are a mix of renderbuffers
205 // and textures, the value of RENDERBUFFER_SAMPLES is zero."
206 //
207 // On creating a renderbuffer: "If _samples_ is zero, then
208 // RENDERBUFFER_SAMPLES is set to zero. Otherwise [...] the resulting
209 // value for RENDERBUFFER_SAMPLES is guaranteed to be greater than or
210 // equal to _samples_ and no more than the next larger sample count
211 // supported by the implementation."
212
213 // Either all attachments are zero-sample renderbuffers and/or
214 // textures, or none of them are.
215 if ((m_numSamples == 0) != (imgSamples == 0))
216 addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, "Mixed multi- and single-sampled attachments");
217
218 // If the attachments requested a different number of samples, the
219 // implementation is allowed to report this as incomplete. However, it
220 // is also possible that despite the different requests, the
221 // implementation allocated the same number of samples to both. Hence
222 // reporting the framebuffer as complete is also legal.
223 if (m_numSamples != imgSamples)
224 addPotentialFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, "Number of samples differ");
225 }
226
227 // "Depth and stencil attachments, if present, are the same image."
228 if (attPoint == GL_DEPTH_ATTACHMENT || attPoint == GL_STENCIL_ATTACHMENT)
229 {
230 if (m_depthStencilImage == 0)
231 {
232 m_depthStencilImage = att.imageName;
233 m_depthStencilType = attachmentType(att);
234 }
235 else
236 {
237 if (m_depthStencilImage != att.imageName || m_depthStencilType != attachmentType(att))
238 addFBOStatus(GL_FRAMEBUFFER_UNSUPPORTED, "Depth and stencil attachments are not the same image");
239 }
240 }
241 }
242
243 struct NumLayersParams
244 {
245 GLenum textureKind; //< GL_TEXTURE_3D or GL_TEXTURE_2D_ARRAY
246 GLsizei numLayers; //< Number of layers in texture
247 GLsizei attachmentLayer; //< Layer referenced by attachment
248
249 static string getName (const NumLayersParams& params);
250 static string getDescription (const NumLayersParams& params);
251 };
252
getName(const NumLayersParams & params)253 string NumLayersParams::getName (const NumLayersParams& params)
254 {
255 ostringstream os;
256 const string kindStr = params.textureKind == GL_TEXTURE_3D ? "3d" : "2darr";
257 os << kindStr << "_" << params.numLayers << "_" << params.attachmentLayer;
258 return os.str();
259 }
260
getDescription(const NumLayersParams & params)261 string NumLayersParams::getDescription (const NumLayersParams& params)
262 {
263 ostringstream os;
264 const string kindStr = (params.textureKind == GL_TEXTURE_3D
265 ? "3D Texture"
266 : "2D Array Texture");
267 os << kindStr + ", "
268 << params.numLayers << " layers, "
269 << "attached layer " << params.attachmentLayer << ".";
270 return os.str();
271 }
272
273 class NumLayersTest : public fboc::ParamTest<NumLayersParams>
274 {
275 public:
NumLayersTest(fboc::Context & ctx,NumLayersParams param)276 NumLayersTest (fboc::Context& ctx, NumLayersParams param)
277 : fboc::ParamTest<NumLayersParams> (ctx, param) {}
278
279 IterateResult build (FboBuilder& builder);
280 };
281
build(FboBuilder & builder)282 IterateResult NumLayersTest::build (FboBuilder& builder)
283 {
284 TextureLayered* texCfg = DE_NULL;
285 const GLenum target = GL_COLOR_ATTACHMENT0;
286
287 switch (m_params.textureKind)
288 {
289 case GL_TEXTURE_3D:
290 texCfg = &builder.makeConfig<Texture3D>();
291 break;
292 case GL_TEXTURE_2D_ARRAY:
293 texCfg = &builder.makeConfig<Texture2DArray>();
294 break;
295 default:
296 DE_FATAL("Impossible case");
297 }
298 texCfg->internalFormat = getDefaultFormat(target, GL_TEXTURE);
299 texCfg->width = 64;
300 texCfg->height = 64;
301 texCfg->numLayers = m_params.numLayers;
302 const GLuint tex = builder.glCreateTexture(*texCfg);
303
304 TextureLayerAttachment* att = &builder.makeConfig<TextureLayerAttachment>();
305 att->layer = m_params.attachmentLayer;
306 att->imageName = tex;
307
308 builder.glAttach(target, att);
309
310 return STOP;
311 }
312
313 enum
314 {
315 SAMPLES_NONE = -2,
316 SAMPLES_TEXTURE = -1
317 };
318 struct NumSamplesParams
319 {
320 // >= 0: renderbuffer with N samples, -1: texture, -2: no attachment
321 GLsizei numSamples[3];
322
323 static string getName (const NumSamplesParams& params);
324 static string getDescription (const NumSamplesParams& params);
325 };
326
getName(const NumSamplesParams & params)327 string NumSamplesParams::getName (const NumSamplesParams& params)
328 {
329 ostringstream os;
330 bool first = true;
331 for (const GLsizei* ns = DE_ARRAY_BEGIN(params.numSamples);
332 ns != DE_ARRAY_END(params.numSamples);
333 ns++)
334 {
335 if (first)
336 first = false;
337 else
338 os << "_";
339
340 if (*ns == SAMPLES_NONE)
341 os << "none";
342 else if (*ns == SAMPLES_TEXTURE)
343 os << "tex";
344 else
345 os << "rbo" << *ns;
346 }
347 return os.str();
348 }
349
getDescription(const NumSamplesParams & params)350 string NumSamplesParams::getDescription (const NumSamplesParams& params)
351 {
352 ostringstream os;
353 bool first = true;
354 static const char* const s_names[] = { "color", "depth", "stencil" };
355 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == DE_LENGTH_OF_ARRAY(params.numSamples));
356
357 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_names); i++)
358 {
359 GLsizei ns = params.numSamples[i];
360
361 if (ns == SAMPLES_NONE)
362 continue;
363
364 if (first)
365 first = false;
366 else
367 os << ", ";
368
369 if (ns == SAMPLES_TEXTURE)
370 os << "texture " << s_names[i] << " attachment";
371 else
372 os << ns << "-sample renderbuffer " << s_names[i] << " attachment";
373 }
374 return os.str();
375 }
376
377 class NumSamplesTest : public fboc::ParamTest<NumSamplesParams>
378 {
379 public:
NumSamplesTest(fboc::Context & ctx,NumSamplesParams param)380 NumSamplesTest (fboc::Context& ctx, NumSamplesParams param)
381 : fboc::ParamTest<NumSamplesParams> (ctx, param) {}
382
383 IterateResult build (FboBuilder& builder);
384 };
385
build(FboBuilder & builder)386 IterateResult NumSamplesTest::build (FboBuilder& builder)
387 {
388 static const GLenum s_targets[] =
389 {
390 GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_DEPTH_ATTACHMENT,
391 };
392 // Non-integer formats for each attachment type.
393 // \todo [2013-12-17 lauri] Add fixed/floating/integer metadata for formats so
394 // we can pick one smartly or maybe try several.
395 static const GLenum s_formats[] =
396 {
397 GL_RGBA8, GL_RGB565, GL_DEPTH_COMPONENT24,
398 };
399 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_targets) == DE_LENGTH_OF_ARRAY(m_params.numSamples));
400
401 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_targets); i++)
402 {
403 const GLenum target = s_targets[i];
404 const ImageFormat fmt = { s_formats[i], GL_NONE };
405
406 const GLsizei ns = m_params.numSamples[i];
407 if (ns == -2)
408 continue;
409
410 if (ns == -1)
411 {
412 attachTargetToNew(target, GL_TEXTURE, fmt, 64, 64, builder);
413 }
414 else
415 {
416 Renderbuffer& rboCfg = builder.makeConfig<Renderbuffer>();
417 rboCfg.internalFormat = fmt;
418 rboCfg.width = rboCfg.height = 64;
419 rboCfg.numSamples = ns;
420
421 const GLuint rbo = builder.glCreateRbo(rboCfg);
422 // Implementations do not necessarily support sample sizes greater than 1.
423 TCU_CHECK_AND_THROW(NotSupportedError,
424 builder.getError() != GL_INVALID_OPERATION,
425 "Unsupported number of samples");
426 RenderbufferAttachment& att = builder.makeConfig<RenderbufferAttachment>();
427 att.imageName = rbo;
428 builder.glAttach(target, &att);
429 }
430 }
431
432 return STOP;
433 }
434
435 class ES3CheckerFactory : public CheckerFactory
436 {
437 public:
createChecker(const glu::RenderContext & ctx)438 Checker* createChecker (const glu::RenderContext& ctx) { return new ES3Checker(ctx); }
439 };
440
441 class TestGroup : public TestCaseGroup
442 {
443 public:
444 TestGroup (Context& context);
445 void init (void);
446 private:
447 ES3CheckerFactory m_checkerFactory;
448 fboc::Context m_fboc;
449 };
450
init(void)451 void TestGroup::init (void)
452 {
453 addChild(m_fboc.createRenderableTests());
454 addChild(m_fboc.createAttachmentTests());
455 addChild(m_fboc.createSizeTests());
456
457 TestCaseGroup* layerTests = new TestCaseGroup(
458 getContext(), "layer", "Tests for layer attachments");
459
460 static const NumLayersParams s_layersParams[] =
461 { // textureKind numLayers attachmentKind
462 { GL_TEXTURE_2D_ARRAY, 1, 0 },
463 { GL_TEXTURE_2D_ARRAY, 1, 3 },
464 { GL_TEXTURE_2D_ARRAY, 4, 3 },
465 { GL_TEXTURE_2D_ARRAY, 4, 15 },
466 { GL_TEXTURE_3D, 1, 0 },
467 { GL_TEXTURE_3D, 1, 15 },
468 { GL_TEXTURE_3D, 4, 15 },
469 { GL_TEXTURE_3D, 64, 15 },
470 };
471
472 for (const NumLayersParams* lp = DE_ARRAY_BEGIN(s_layersParams);
473 lp != DE_ARRAY_END(s_layersParams);
474 ++lp)
475 layerTests->addChild(new NumLayersTest(m_fboc, *lp));
476
477 addChild(layerTests);
478
479 TestCaseGroup* sampleTests = new TestCaseGroup(
480 getContext(), "samples", "Tests for multisample attachments");
481
482 static const NumSamplesParams s_samplesParams[] =
483 {
484 { { 0, SAMPLES_NONE, SAMPLES_NONE } },
485 { { 1, SAMPLES_NONE, SAMPLES_NONE } },
486 { { 2, SAMPLES_NONE, SAMPLES_NONE } },
487 { { 0, SAMPLES_TEXTURE, SAMPLES_NONE } },
488 { { 1, SAMPLES_TEXTURE, SAMPLES_NONE } },
489 { { 2, SAMPLES_TEXTURE, SAMPLES_NONE } },
490 { { 2, 1, SAMPLES_NONE } },
491 { { 2, 2, SAMPLES_NONE } },
492 { { 0, 0, SAMPLES_TEXTURE } },
493 { { 1, 2, 0 } },
494 { { 2, 2, 0 } },
495 { { 1, 1, 1 } },
496 { { 1, 2, 4 } },
497 };
498
499 for (const NumSamplesParams* lp = DE_ARRAY_BEGIN(s_samplesParams);
500 lp != DE_ARRAY_END(s_samplesParams);
501 ++lp)
502 sampleTests->addChild(new NumSamplesTest(m_fboc, *lp));
503
504 addChild(sampleTests);
505 }
506
TestGroup(Context & ctx)507 TestGroup::TestGroup (Context& ctx)
508 : TestCaseGroup (ctx, "completeness", "Completeness tests")
509 , m_checkerFactory ()
510 , m_fboc (ctx.getTestContext(), ctx.getRenderContext(), m_checkerFactory)
511 {
512 const FormatEntries stdRange = GLS_ARRAY_RANGE(s_es3Formats);
513 const FormatExtEntries extRange = GLS_ARRAY_RANGE(s_es3ExtFormats);
514
515 m_fboc.addFormats(stdRange);
516 m_fboc.addExtFormats(extRange);
517 m_fboc.setHaveMulticolorAtts(true); // Vanilla ES3 has multiple color attachments
518 }
519
createFboCompletenessTests(Context & context)520 tcu::TestCaseGroup* createFboCompletenessTests (Context& context)
521 {
522 return new TestGroup(context);
523 }
524
525 } // Functional
526 } // gles3
527 } // deqp
528