modules/glshared/glsLifetimeTests.hpp

   1 #ifndef _GLSLIFETIMETESTS_HPP
   2 #define _GLSLIFETIMETESTS_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program OpenGL (ES) Module
   5  * -----------------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Common object lifetime tests.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "deRandom.hpp"
  27 #include "deUniquePtr.hpp"
  28 #include "tcuSurface.hpp"
  29 #include "tcuTestCase.hpp"
  30 #include "tcuTestContext.hpp"
  31 #include "gluCallLogWrapper.hpp"
  32 #include "gluRenderContext.hpp"
  33 #include "glwDefs.hpp"
  34 #include "glwEnums.hpp"
  35
  36 #include <vector>
  37
  38 namespace deqp
  39 {
  40 namespace gls
  41 {
  42 namespace LifetimeTests
  43 {
  44 namespace details
  45 {
  46
  47 using std::vector;
  48 using de::MovePtr;
  49 using de::Random;
  50 using tcu::Surface;
  51 using tcu::TestCaseGroup;
  52 using tcu::TestContext;
  53 using tcu::TestLog;
  54 using glu::CallLogWrapper;
  55 using glu::RenderContext;
  56 using namespace glw;
  57
  58 typedef void            (CallLogWrapper::*BindFunc)             (GLenum target, GLuint name);
  59 typedef void            (CallLogWrapper::*GenFunc)              (GLsizei n, GLuint* names);
  60 typedef void            (CallLogWrapper::*DeleteFunc)   (GLsizei n, const GLuint* names);
  61 typedef GLboolean       (CallLogWrapper::*ExistsFunc)   (GLuint name);
  62
  63 class Context
  64 {
  65 public:
  66                                                         Context                         (const RenderContext& renderCtx,
  67                                                                                                  TestContext& testCtx)
  68                                                                 : m_renderCtx   (renderCtx)
  69                                                                 , m_testCtx             (testCtx) {}
  70         const RenderContext&    getRenderContext        (void) const { return m_renderCtx; }
  71         TestContext&                    getTestContext          (void) const { return m_testCtx; }
  72         const Functions&                gl                                      (void) const { return m_renderCtx.getFunctions(); }
  73         TestLog&                                log                                     (void) const { return m_testCtx.getLog(); }
  74
  75 private:
  76         const RenderContext&    m_renderCtx;
  77         TestContext&                    m_testCtx;
  78 };
  79
  80 class ContextWrapper : public CallLogWrapper
  81 {
  82 public:
  83         const Context&                  getContext                      (void) const { return m_ctx; }
  84         const RenderContext&    getRenderContext        (void) const { return m_ctx.getRenderContext(); }
  85         TestContext&                    getTestContext          (void) const { return m_ctx.getTestContext(); }
  86         const Functions&                gl                                      (void) const { return m_ctx.gl(); }
  87         TestLog&                                log                                     (void) const { return m_ctx.log(); }
  88         void                                    enableLogging           (bool enable)
  89         {
  90                 CallLogWrapper::enableLogging(enable);
  91         }
  92
  93 protected:
  94                                                         ContextWrapper                          (const Context& ctx);
  95         const Context                   m_ctx;
  96 };
  97
  98 class Binder : public ContextWrapper
  99 {
 100 public:
 101         virtual                         ~Binder                 (void) {}
 102         virtual void            bind                    (GLuint name) = 0;
 103         virtual GLuint          getBinding              (void) = 0;
 104         virtual bool            genRequired             (void) const { return true; }
 105
 106 protected:
 107                                                 Binder                  (const Context& ctx) : ContextWrapper(ctx) {}
 108 };
 109
 110 class SimpleBinder : public Binder
 111 {
 112 public:
 113                                                 SimpleBinder    (const Context& ctx,
 114                                                                                  BindFunc bindFunc,
 115                                                                                  GLenum bindTarget,
 116                                                                                  GLenum bindingParam,
 117                                                                                  bool genRequired_ = false)
 118                                                         : Binder                        (ctx)
 119                                                         , m_bindFunc            (bindFunc)
 120                                                         , m_bindTarget          (bindTarget)
 121                                                         , m_bindingParam        (bindingParam)
 122                                                         , m_genRequired         (genRequired_) {}
 123
 124         void                            bind                    (GLuint name);
 125         GLuint                          getBinding              (void);
 126         bool                            genRequired             (void) const { return m_genRequired; }
 127
 128 private:
 129         const BindFunc          m_bindFunc;
 130         const GLenum            m_bindTarget;
 131         const GLenum            m_bindingParam;
 132         const bool                      m_genRequired;
 133 };
 134
 135 class Type : public ContextWrapper
 136 {
 137 public:
 138         virtual                                 ~Type                   (void) {}
 139         virtual GLuint                  gen                             (void) = 0;
 140         virtual void                    release                 (GLuint name) = 0;
 141         virtual bool                    exists                  (GLuint name) = 0;
 142         virtual bool                    isDeleteFlagged (GLuint name) { DE_UNREF(name); return false; }
 143         virtual Binder*                 binder                  (void) const { return DE_NULL; }
 144         virtual const char*             getName                 (void) const = 0;
 145         virtual bool                    nameLingers             (void) const { return false; }
 146         virtual bool                    genCreates              (void) const { return false; }
 147
 148 protected:
 149                                                         Type                    (const Context& ctx) : ContextWrapper(ctx) {}
 150 };
 151
 152 class SimpleType : public Type
 153 {
 154 public:
 155                                 SimpleType      (const Context& ctx, const char* name,
 156                                                          GenFunc genFunc, DeleteFunc deleteFunc, ExistsFunc existsFunc,
 157                                                          Binder* binder_ = DE_NULL, bool genCreates_ = false)
 158                                                 : Type                  (ctx)
 159                                                 , m_getName             (name)
 160                                                 , m_genFunc             (genFunc)
 161                                                 , m_deleteFunc  (deleteFunc)
 162                                                 , m_existsFunc  (existsFunc)
 163                                                 , m_binder              (binder_)
 164                                                 , m_genCreates  (genCreates_) {}
 165
 166         GLuint                  gen                     (void);
 167         void                    release         (GLuint name)           { (this->*m_deleteFunc)(1, &name); }
 168         bool                    exists          (GLuint name)           { return (this->*m_existsFunc)(name) != GL_FALSE; }
 169         Binder*                 binder          (void) const            { return m_binder; }
 170         const char*             getName         (void) const            { return m_getName; }
 171         bool                    nameLingers     (void) const            { return false; }
 172         bool                    genCreates      (void) const            { return m_genCreates; }
 173
 174 private:
 175         const char* const       m_getName;
 176         const GenFunc           m_genFunc;
 177         const DeleteFunc        m_deleteFunc;
 178         const ExistsFunc        m_existsFunc;
 179         Binder* const           m_binder;
 180         const bool                      m_genCreates;
 181 };
 182
 183 class ProgramType : public Type
 184 {
 185 public:
 186                                         ProgramType             (const Context& ctx) : Type(ctx) {}
 187         bool                    nameLingers             (void) const    { return true; }
 188         bool                    genCreates              (void) const    { return true; }
 189         const char*             getName                 (void) const    { return "program"; }
 190         GLuint                  gen                             (void)                  { return glCreateProgram(); }
 191         void                    release                 (GLuint name)   { glDeleteProgram(name); }
 192         bool                    exists                  (GLuint name)   { return glIsProgram(name) != GL_FALSE; }
 193         bool                    isDeleteFlagged (GLuint name);
 194 };
 195
 196 class ShaderType : public Type
 197 {
 198 public:
 199                                         ShaderType              (const Context& ctx) : Type(ctx) {}
 200         bool                    nameLingers             (void) const { return true; }
 201         bool                    genCreates              (void) const { return true; }
 202         const char*             getName                 (void) const { return "shader"; }
 203         GLuint                  gen                             (void) { return glCreateShader(GL_FRAGMENT_SHADER); }
 204         void                    release                 (GLuint name) { glDeleteShader(name); }
 205         bool                    exists                  (GLuint name) { return glIsShader(name) != GL_FALSE; }
 206         bool                    isDeleteFlagged (GLuint name);
 207 };
 208
 209 class Attacher : public ContextWrapper
 210 {
 211 public:
 212         virtual void            initAttachment                  (GLuint seed, GLuint attachment) = 0;
 213         virtual void            attach                                  (GLuint element, GLuint container) = 0;
 214         virtual void            detach                                  (GLuint element, GLuint container) = 0;
 215         virtual GLuint          getAttachment                   (GLuint container) = 0;
 216         virtual bool            canAttachDeleted                (void) const { return true; }
 217
 218         Type&                           getElementType                  (void) const { return m_elementType; }
 219         Type&                           getContainerType                (void) const { return m_containerType; }
 220         virtual                         ~Attacher                               (void) {}
 221
 222 protected:
 223                                                 Attacher                                (const Context& ctx,
 224                                                                                                  Type& elementType, Type& containerType)
 225                                                         : ContextWrapper        (ctx)
 226                                                         , m_elementType         (elementType)
 227                                                         , m_containerType       (containerType) {}
 228
 229 private:
 230         Type&                           m_elementType;
 231         Type&                           m_containerType;
 232 };
 233
 234 class InputAttacher : public ContextWrapper
 235 {
 236 public:
 237         Attacher&                       getAttacher                             (void) const { return m_attacher; }
 238         virtual void            drawContainer                   (GLuint container, Surface& dst) = 0;
 239 protected:
 240                                                 InputAttacher                   (Attacher& attacher)
 241                                                         : ContextWrapper        (attacher.getContext())
 242                                                         , m_attacher            (attacher) {}
 243         Attacher&                       m_attacher;
 244 };
 245
 246 class OutputAttacher : public ContextWrapper
 247 {
 248 public:
 249         Attacher&                       getAttacher                             (void) const { return m_attacher; }
 250         virtual void            setupContainer                  (GLuint seed, GLuint container) = 0;
 251         virtual void            drawAttachment                  (GLuint attachment, Surface& dst) = 0;
 252 protected:
 253                                                 OutputAttacher                  (Attacher& attacher)
 254                                                         : ContextWrapper        (attacher.getContext())
 255                                                         , m_attacher            (attacher) {}
 256         Attacher&                       m_attacher;
 257 };
 258
 259 class Types : public ContextWrapper
 260 {
 261 public:
 262                                                                         Types                           (const Context& ctx)
 263                                                                                 : ContextWrapper(ctx) {}
 264         virtual Type&                                   getProgramType          (void) = 0;
 265         const vector<Type*>&                    getTypes                        (void) { return m_types; }
 266         const vector<Attacher*>&                getAttachers            (void) { return m_attachers; }
 267         const vector<InputAttacher*>&   getInputAttachers       (void) { return m_inAttachers; }
 268         const vector<OutputAttacher*>&  getOutputAttachers      (void) { return m_outAttachers; }
 269         virtual                                                 ~Types                          (void) {}
 270
 271 protected:
 272         vector<Type*>                                   m_types;
 273         vector<Attacher*>                               m_attachers;
 274         vector<InputAttacher*>                  m_inAttachers;
 275         vector<OutputAttacher*>                 m_outAttachers;
 276 };
 277
 278 class FboAttacher : public Attacher
 279 {
 280 public:
 281         void                    initAttachment          (GLuint seed, GLuint element);
 282
 283 protected:
 284                                         FboAttacher                     (const Context& ctx,
 285                                                                                  Type& elementType, Type& containerType)
 286                                                 : Attacher              (ctx, elementType, containerType) {}
 287         virtual void    initStorage                     (void) = 0;
 288 };
 289
 290 class FboInputAttacher : public InputAttacher
 291 {
 292 public:
 293                         FboInputAttacher                (FboAttacher& attacher)
 294                                 : InputAttacher         (attacher) {}
 295         void    drawContainer                   (GLuint container, Surface& dst);
 296 };
 297
 298 class FboOutputAttacher : public OutputAttacher
 299 {
 300 public:
 301                         FboOutputAttacher                       (FboAttacher& attacher)
 302                                 : OutputAttacher                (attacher) {}
 303         void    setupContainer                          (GLuint seed, GLuint container);
 304         void    drawAttachment                          (GLuint attachment, Surface& dst);
 305 };
 306
 307 class TextureFboAttacher : public FboAttacher
 308 {
 309 public:
 310                         TextureFboAttacher      (const Context& ctx, Type& elementType, Type& containerType)
 311                                 : FboAttacher   (ctx, elementType, containerType) {}
 312
 313         void    initStorage                     (void);
 314         void    attach                          (GLuint element, GLuint container);
 315         void    detach                          (GLuint element, GLuint container);
 316         GLuint  getAttachment           (GLuint container);
 317 };
 318
 319 class RboFboAttacher : public FboAttacher
 320 {
 321 public:
 322                         RboFboAttacher          (const Context& ctx, Type& elementType, Type& containerType)
 323                                 : FboAttacher   (ctx, elementType, containerType) {}
 324
 325         void    initStorage                     (void);
 326         void    attach                          (GLuint element, GLuint container);
 327         void    detach                          (GLuint element, GLuint container);
 328         GLuint  getAttachment           (GLuint container);
 329 };
 330
 331 class ShaderProgramAttacher : public Attacher
 332 {
 333 public:
 334                         ShaderProgramAttacher   (const Context& ctx,
 335                                                                          Type& elementType, Type& containerType)
 336                                 : Attacher                      (ctx, elementType, containerType) {}
 337
 338         void    initAttachment          (GLuint seed, GLuint element);
 339         void    attach                          (GLuint element, GLuint container);
 340         void    detach                          (GLuint element, GLuint container);
 341         GLuint  getAttachment           (GLuint container);
 342 };
 343
 344 class ShaderProgramInputAttacher : public InputAttacher
 345 {
 346 public:
 347                         ShaderProgramInputAttacher      (Attacher& attacher)
 348                                 : InputAttacher                 (attacher) {}
 349
 350         void    drawContainer                           (GLuint container, Surface& dst);
 351 };
 352
 353 class ES2Types : public Types
 354 {
 355 public:
 356                                                                 ES2Types                (const Context& ctx);
 357         Type&                                           getProgramType  (void) { return m_programType; }
 358
 359 protected:
 360         SimpleBinder                            m_bufferBind;
 361         SimpleType                                      m_bufferType;
 362         SimpleBinder                            m_textureBind;
 363         SimpleType                                      m_textureType;
 364         SimpleBinder                            m_rboBind;
 365         SimpleType                                      m_rboType;
 366         SimpleBinder                            m_fboBind;
 367         SimpleType                                      m_fboType;
 368         ShaderType                                      m_shaderType;
 369         ProgramType                                     m_programType;
 370         TextureFboAttacher                      m_texFboAtt;
 371         FboInputAttacher                        m_texFboInAtt;
 372         FboOutputAttacher                       m_texFboOutAtt;
 373         RboFboAttacher                          m_rboFboAtt;
 374         FboInputAttacher                        m_rboFboInAtt;
 375         FboOutputAttacher                       m_rboFboOutAtt;
 376         ShaderProgramAttacher           m_shaderAtt;
 377         ShaderProgramInputAttacher      m_shaderInAtt;
 378 };
 379
 380 MovePtr<TestCaseGroup>  createGroup             (TestContext& testCtx, Type& type);
 381 void                                    addTestCases    (TestCaseGroup& group, Types& types);
 382
 383 struct Rectangle
 384 {
 385                         Rectangle       (GLint x_, GLint y_, GLint width_, GLint height_)
 386                                 : x                     (x_)
 387                                 , y                     (y_)
 388                                 , width         (width_)
 389                                 , height        (height_) {}
 390         GLint   x;
 391         GLint   y;
 392         GLint   width;
 393         GLint   height;
 394 };
 395
 396 Rectangle       randomViewport  (const RenderContext& ctx, GLint maxWidth, GLint maxHeight,
 397                                                          Random& rnd);
 398 void            setViewport             (const RenderContext& renderCtx, const Rectangle& rect);
 399 void            readRectangle   (const RenderContext& renderCtx, const Rectangle& rect,
 400                                                          Surface& dst);
 401
 402 } // details
 403
 404 using details::BindFunc;
 405 using details::GenFunc;
 406 using details::DeleteFunc;
 407 using details::ExistsFunc;
 408
 409 using details::Context;
 410 using details::Binder;
 411 using details::SimpleBinder;
 412 using details::Type;
 413 using details::SimpleType;
 414 using details::Attacher;
 415 using details::InputAttacher;
 416 using details::OutputAttacher;
 417 using details::Types;
 418 using details::ES2Types;
 419
 420 using details::createGroup;
 421 using details::addTestCases;
 422
 423 using details::Rectangle;
 424 using details::randomViewport;
 425 using details::setViewport;
 426 using details::readRectangle;
 427
 428 } // LifetimeTests
 429 } // gls
 430 } // deqp
 431
 432 #endif // _GLSLIFETIMETESTS_HPP