1 #ifndef _GLSFBOUTIL_HPP
2 #define _GLSFBOUTIL_HPP
3
4 /*-------------------------------------------------------------------------
5 * drawElements Quality Program OpenGL (ES) Module
6 * -----------------------------------------------
7 *
8 * Copyright 2014 The Android Open Source Project
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 *
22 *//*!
23 * \file
24 * \brief Utilities for framebuffer objects.
25 *//*--------------------------------------------------------------------*/
26
27 #include "gluRenderContext.hpp"
28 #include "gluContextInfo.hpp"
29 #include "glwDefs.hpp"
30 #include "glwEnums.hpp"
31 #include "glwFunctions.hpp"
32 #include "gluTextureUtil.hpp"
33 #include "tcuTestLog.hpp"
34 #include "tcuDefs.hpp"
35
36 #include <map>
37 #include <set>
38 #include <vector>
39 #include <algorithm>
40 #include <iterator>
41
42 namespace deqp
43 {
44 namespace gls
45 {
46
47 //! A pair of iterators to present a range.
48 //! \note This must be POD to allow static initialization.
49 //! \todo [2013-12-03 lauri] Move this to decpp?
50 template <typename T>
51 struct Range
52 {
53 typedef const T* const_iterator;
54
55 const T* m_begin;
56 const T* m_end;
57
begindeqp::gls::Range58 const T* begin (void) const { return m_begin; }
enddeqp::gls::Range59 const T* end (void) const { return m_end; }
60 };
61
62 #define GLS_ARRAY_RANGE(ARR) { DE_ARRAY_BEGIN(ARR), DE_ARRAY_END(ARR) }
63
64 #define GLS_NULL_RANGE { DE_NULL, DE_NULL }
65
66
67 //! A pair type that, unlike stl::pair, is POD so it can be statically initialized.
68 template <typename T1, typename T2>
69 struct Pair
70 {
71 typedef T1 first_type;
72 typedef T2 second_type;
73 T1 first;
74 T2 second;
75 };
76
77 namespace FboUtil
78 {
79
80 //! Configurations for framebuffer objects and their attachments.
81
82 class FboVerifier;
83 class FboBuilder;
84
85 typedef deUint32 FormatKey;
86
87 #define GLS_UNSIZED_FORMATKEY(FORMAT, TYPE) \
88 (deUint32(TYPE) << 16 | deUint32(FORMAT))
89
90 typedef Range<FormatKey> FormatKeys;
91
92 struct ImageFormat
93 {
94 glw::GLenum format;
95
96 //! Type if format is unsized, GL_NONE if sized.
97 glw::GLenum unsizedType;
98
operator <deqp::gls::FboUtil::ImageFormat99 bool operator< (const ImageFormat& other) const
100 {
101 return (format < other.format ||
102 (format == other.format && unsizedType < other.unsizedType));
103 }
104
nonedeqp::gls::FboUtil::ImageFormat105 static ImageFormat none (void)
106 {
107 ImageFormat fmt = { GL_NONE, GL_NONE };
108 return fmt;
109 }
110 };
111
112 std::ostream& operator<< (std::ostream& stream, const ImageFormat& format);
113
formatKeyInfo(FormatKey key)114 static inline ImageFormat formatKeyInfo(FormatKey key)
115 {
116 ImageFormat fmt = { key & 0xffff, key >> 16 };
117 return fmt;
118 }
119
120 enum FormatFlags
121 {
122 ANY_FORMAT = 0,
123 COLOR_RENDERABLE = 1 << 0,
124 DEPTH_RENDERABLE = 1 << 1,
125 STENCIL_RENDERABLE = 1 << 2,
126 RENDERBUFFER_VALID = 1 << 3,
127 TEXTURE_VALID = 1 << 4,
128 REQUIRED_RENDERABLE = 1 << 5, //< Without this, renderability is allowed, not required.
129 };
130
operator |(FormatFlags f1,FormatFlags f2)131 static inline FormatFlags operator|(FormatFlags f1, FormatFlags f2)
132 {
133 return FormatFlags(deUint32(f1) | deUint32(f2));
134 }
135
136 FormatFlags formatFlag(glw::GLenum context);
137
138 typedef std::set<ImageFormat> Formats;
139
140 class FormatDB
141 {
142 public:
143 void addCoreFormat (ImageFormat format, FormatFlags flags);
144 void addExtensionFormat (ImageFormat format, FormatFlags flags, const std::set<std::string>& requiredExtensions);
145
146 Formats getFormats (FormatFlags requirements) const;
147 bool isKnownFormat (ImageFormat format) const;
148 FormatFlags getFormatInfo (ImageFormat format) const;
149 std::set<std::set<std::string> > getFormatFeatureExtensions (ImageFormat format, FormatFlags requirements) const;
150
151 private:
152 struct ExtensionInfo
153 {
154 FormatFlags flags;
155 std::set<std::string> requiredExtensions;
156
157 bool operator< (const ExtensionInfo& other) const;
158 };
159
160 typedef std::map<ImageFormat, FormatFlags> FormatMap;
161 typedef std::map<ImageFormat, std::set<ExtensionInfo> > FormatExtensionMap;
162
163 FormatMap m_formatFlags;
164 FormatExtensionMap m_formatExtensions;
165 };
166
167 typedef Pair<FormatFlags, FormatKeys> FormatEntry;
168 typedef Range<FormatEntry> FormatEntries;
169
170 // \todo [2013-12-20 lauri] It turns out that format properties in extensions
171 // are actually far too fine-grained for this bundling to be reasonable,
172 // especially given the syntactic cumbersomeness of static arrays. It's better
173 // to list each entry separately.
174
175 struct FormatExtEntry
176 {
177 const char* extensions;
178 deUint32 flags;
179 Range<FormatKey> formats;
180 };
181
182 typedef Range<FormatExtEntry> FormatExtEntries;
183
184 // Check support for GL_* and DEQP_* extensions
185 bool checkExtensionSupport (const glu::RenderContext& ctx, const std::string& extension);
186
187 // Accepts GL_* and DEQP_* extension strings and converts DEQP_* strings to a human readable string
188 std::string getExtensionDescription (const std::string& extensionName);
189
190 void addFormats (FormatDB& db, FormatEntries stdFmts);
191 void addExtFormats (FormatDB& db, FormatExtEntries extFmts, const glu::RenderContext* ctx);
192 glu::TransferFormat transferImageFormat (const ImageFormat& imgFormat);
193
194 namespace config
195 {
196
197 struct Config
198 {
~Configdeqp::gls::FboUtil::config::Config199 virtual ~Config (void) {}
200 };
201
202 struct Image : public Config
203 {
204 ImageFormat internalFormat;
205 glw::GLsizei width;
206 glw::GLsizei height;
207
208 protected:
Imagedeqp::gls::FboUtil::config::Image209 Image (void)
210 : internalFormat (ImageFormat::none())
211 , width (0)
212 , height (0) {}
213 };
214
215 struct Renderbuffer : public Image
216 {
Renderbufferdeqp::gls::FboUtil::config::Renderbuffer217 Renderbuffer (void) : numSamples(0) {}
218
219 glw::GLsizei numSamples;
220 };
221
222 struct Texture : public Image
223 {
Texturedeqp::gls::FboUtil::config::Texture224 Texture (void) : numLevels(1) {}
225
226 glw::GLint numLevels;
227 };
228
229 struct TextureFlat : public Texture
230 {
231 };
232
233 struct Texture2D : public TextureFlat
234 {
235 };
236
237 struct TextureCubeMap : public TextureFlat
238 {
239 };
240
241 struct TextureLayered : public Texture
242 {
TextureLayereddeqp::gls::FboUtil::config::TextureLayered243 TextureLayered (void) : numLayers(1) {}
244 glw::GLsizei numLayers;
245 };
246
247 struct Texture3D : public TextureLayered
248 {
249 };
250
251 struct Texture2DArray : public TextureLayered
252 {
253 };
254
255 struct Attachment : public Config
256 {
Attachmentdeqp::gls::FboUtil::config::Attachment257 Attachment (void) : target(GL_FRAMEBUFFER), imageName(0) {}
258
259 glw::GLenum target;
260 glw::GLuint imageName;
261
262 //! Returns `true` iff this attachment is "framebuffer attachment
263 //! complete" when bound to attachment point `attPoint`, and the current
264 //! image with name `imageName` is `image`, using `vfr` to check format
265 //! renderability.
266 bool isComplete (glw::GLenum attPoint, const Image* image,
267 const FboVerifier& vfr) const;
268 };
269
270 struct RenderbufferAttachment : public Attachment
271 {
RenderbufferAttachmentdeqp::gls::FboUtil::config::RenderbufferAttachment272 RenderbufferAttachment (void)
273 : renderbufferTarget(GL_RENDERBUFFER) {}
274
275 glw::GLenum renderbufferTarget;
276 };
277
278 struct TextureAttachment : public Attachment
279 {
TextureAttachmentdeqp::gls::FboUtil::config::TextureAttachment280 TextureAttachment (void) : level(0) {}
281
282 glw::GLint level;
283 };
284
285 struct TextureFlatAttachment : public TextureAttachment
286 {
TextureFlatAttachmentdeqp::gls::FboUtil::config::TextureFlatAttachment287 TextureFlatAttachment (void) : texTarget(GL_NONE) {}
288
289 glw::GLenum texTarget;
290 };
291
292 struct TextureLayerAttachment : public TextureAttachment
293 {
TextureLayerAttachmentdeqp::gls::FboUtil::config::TextureLayerAttachment294 TextureLayerAttachment (void) : layer(0) {}
295
296 glw::GLsizei layer;
297 };
298
299 glw::GLenum attachmentType (const Attachment& att);
300 glw::GLsizei imageNumSamples (const Image& img);
301
302 //! Mapping from attachment points to attachment configurations.
303 typedef std::map<glw::GLenum, const Attachment*> AttachmentMap;
304
305 //! Mapping from object names to texture configurations.
306 typedef std::map<glw::GLuint, const Texture*> TextureMap;
307
308 //! Mapping from object names to renderbuffer configurations.
309 typedef std::map<glw::GLuint, const Renderbuffer*> RboMap;
310
311 //! A framebuffer configuration.
312 struct Framebuffer
313 {
314 AttachmentMap attachments;
315 TextureMap textures;
316 RboMap rbos;
317
318 void attach (glw::GLenum attPoint, const Attachment* att);
319 void setTexture (glw::GLuint texName, const Texture& texCfg);
320 void setRbo (glw::GLuint rbName, const Renderbuffer& rbCfg);
321 const Image* getImage (glw::GLenum type, glw::GLuint imgName) const;
322 };
323
324 } // config
325
326 class FboBuilder : public config::Framebuffer
327 {
328 public:
329 void glAttach (glw::GLenum attPoint,
330 const config::Attachment* att);
331 glw::GLuint glCreateTexture (const config::Texture& texCfg);
332 glw::GLuint glCreateRbo (const config::Renderbuffer& rbCfg);
333 FboBuilder (glw::GLuint fbo, glw::GLenum target,
334 const glw::Functions& gl);
335 ~FboBuilder (void);
getError(void)336 glw::GLenum getError (void) { return m_error; }
337
338 //! Allocate a new configuration of type `Config` (which must be a
339 //! subclass of `config::Config`), and return a referenc to it. The newly
340 //! allocated object will be freed when this builder object is destroyed.
341 template<typename Config>
makeConfig(void)342 Config& makeConfig (void)
343 {
344 Config* cfg = new Config();
345 m_configs.insert(cfg);
346 return *cfg;
347 }
348
349 private:
350 typedef std::set<config::Config*> Configs;
351
352 void checkError (void);
353
354 glw::GLenum m_error; //< The first GL error encountered.
355 glw::GLenum m_target;
356 const glw::Functions& m_gl;
357 Configs m_configs;
358 };
359
360 struct ValidStatusCodes
361 {
362 ValidStatusCodes (void);
363
364 bool isFBOStatusValid (glw::GLenum fboStatus) const;
365 bool isFBOStatusRequired (glw::GLenum fboStatus) const;
366 bool isErrorCodeValid (glw::GLenum errorCode) const;
367 bool isErrorCodeRequired (glw::GLenum errorCode) const;
368
369 void addErrorCode (glw::GLenum error, const char* description);
370 void addFBOErrorStatus (glw::GLenum status, const char* description);
371 void setAllowComplete (bool);
372
373 void logLegalResults (tcu::TestLog& log) const;
374 void logRules (tcu::TestLog& log) const;
375
376 private:
377 struct RuleViolation
378 {
379 glw::GLenum errorCode;
380 std::set<std::string> rules;
381 };
382
383 void logRule (tcu::TestLog& log, const std::string& ruleName, const std::set<std::string>& rules) const;
384 void addViolation (std::vector<RuleViolation>& dst, glw::GLenum code, const char* description) const;
385
386 std::vector<RuleViolation> m_errorCodes; //!< Allowed GL errors, GL_NO_ERROR is not allowed
387 std::vector<RuleViolation> m_errorStatuses; //!< Allowed FBO error statuses, GL_FRAMEBUFFER_COMPLETE is not allowed
388 bool m_allowComplete; //!< true if (GL_NO_ERROR && GL_FRAMEBUFFER_COMPLETE) is allowed
389 };
390
391 void logFramebufferConfig (const config::Framebuffer& cfg, tcu::TestLog& log);
392
393 class Checker
394 {
395 public:
396 Checker (const glu::RenderContext&, const FormatDB&);
~Checker(void)397 virtual ~Checker (void) {}
398
399 void addGLError (glw::GLenum error, const char* description);
400 void addPotentialGLError (glw::GLenum error, const char* description);
401 void addFBOStatus (glw::GLenum status, const char* description);
402 void addPotentialFBOStatus (glw::GLenum status, const char* description);
403
getStatusCodes(void)404 ValidStatusCodes getStatusCodes (void) { return m_statusCodes; }
405
406 virtual void check (glw::GLenum attPoint,
407 const config::Attachment& att,
408 const config::Image* image) = 0;
409
410 protected:
411 const glu::RenderContext& m_renderCtx;
412 const FormatDB& m_formats;
413
414 private:
415 ValidStatusCodes m_statusCodes; //< Allowed return values for glCheckFramebufferStatus.
416 };
417
418 class CheckerFactory
419 {
420 public:
421 virtual Checker* createChecker (const glu::RenderContext&, const FormatDB&) = 0;
422 };
423
424 typedef std::set<glw::GLenum> AttachmentPoints;
425 typedef std::set<ImageFormat> Formats;
426
427 class FboVerifier
428 {
429 public:
430 FboVerifier (const FormatDB& formats,
431 CheckerFactory& factory,
432 const glu::RenderContext& renderCtx);
433
434 ValidStatusCodes validStatusCodes (const config::Framebuffer& cfg) const;
435
436 private:
437 const FormatDB& m_formats;
438 CheckerFactory& m_factory;
439 const glu::RenderContext& m_renderCtx;
440 };
441
442 } // FboUtil
443 } // gls
444 } // deqp
445
446 #endif // _GLSFBOUTIL_HPP
447