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 58 const T* begin (void) const { return m_begin; } 59 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 99 bool operator< (const ImageFormat& other) const 100 { 101 return (format < other.format || 102 (format == other.format && unsizedType < other.unsizedType)); 103 } 104 105 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 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 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 { 199 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: 209 Image (void) 210 : internalFormat (ImageFormat::none()) 211 , width (0) 212 , height (0) {} 213 }; 214 215 struct Renderbuffer : public Image 216 { 217 Renderbuffer (void) : numSamples(0) {} 218 219 glw::GLsizei numSamples; 220 }; 221 222 struct Texture : public Image 223 { 224 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 { 243 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 { 257 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 { 272 RenderbufferAttachment (void) 273 : renderbufferTarget(GL_RENDERBUFFER) {} 274 275 glw::GLenum renderbufferTarget; 276 }; 277 278 struct TextureAttachment : public Attachment 279 { 280 TextureAttachment (void) : level(0) {} 281 282 glw::GLint level; 283 }; 284 285 struct TextureFlatAttachment : public TextureAttachment 286 { 287 TextureFlatAttachment (void) : texTarget(GL_NONE) {} 288 289 glw::GLenum texTarget; 290 }; 291 292 struct TextureLayerAttachment : public TextureAttachment 293 { 294 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); 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> 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&); 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 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 413 private: 414 ValidStatusCodes m_statusCodes; //< Allowed return values for glCheckFramebufferStatus. 415 }; 416 417 class CheckerFactory 418 { 419 public: 420 virtual Checker* createChecker (const glu::RenderContext&) = 0; 421 }; 422 423 typedef std::set<glw::GLenum> AttachmentPoints; 424 typedef std::set<ImageFormat> Formats; 425 426 class FboVerifier 427 { 428 public: 429 FboVerifier (const FormatDB& formats, 430 CheckerFactory& factory, 431 const glu::RenderContext& renderCtx); 432 433 ValidStatusCodes validStatusCodes (const config::Framebuffer& cfg) const; 434 435 private: 436 const FormatDB& m_formats; 437 CheckerFactory& m_factory; 438 const glu::RenderContext& m_renderCtx; 439 }; 440 441 } // FboUtil 442 } // gls 443 } // deqp 444 445 #endif // _GLSFBOUTIL_HPP 446
