automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h

   1 #ifndef TEST_GL_ABSTRACTION_H
   2 #define TEST_GL_ABSTRACTION_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   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
  21 // EXTERNAL INCLUDES
  22 #include <cstdio>
  23 #include <cstring>
  24 #include <cstring> // for strcmp
  25 #include <map>
  26 #include <sstream>
  27 #include <string>
  28 #include <typeinfo>
  29
  30 // INTERNAL INCLUDES
  31 #include <dali/devel-api/rendering/frame-buffer-devel.h>
  32 #include <dali/integration-api/core.h>
  33 #include <dali/integration-api/gl-abstraction.h>
  34 #include <dali/integration-api/gl-defines.h>
  35 #include <dali/public-api/dali-core.h>
  36 #include <test-compare-types.h>
  37 #include <test-trace-call-stack.h>
  38
  39 namespace Dali
  40 {
  41 struct UniformData
  42 {
  43   std::string    name;
  44   Property::Type type;
  45   UniformData(const std::string& name, Property::Type type = Property::Type::NONE)
  46   : name(name),
  47     type(type)
  48   {
  49   }
  50 };
  51
  52 struct ActiveUniform
  53 {
  54   std::string name;
  55   GLenum      type;
  56   GLint       size;
  57 };
  58
  59 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
  60 {
  61 public:
  62   static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
  63
  64   TestGlAbstraction();
  65   ~TestGlAbstraction() override;
  66   void Initialize();
  67
  68   void PreRender() override;
  69   void PostRender() override;
  70
  71   bool IsSurfacelessContextSupported() const override;
  72
  73   bool IsAdvancedBlendEquationSupported() override;
  74
  75   bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
  76
  77   std::string GetShaderVersionPrefix();
  78
  79   std::string GetVertexShaderPrefix();
  80
  81   std::string GetFragmentShaderPrefix();
  82
  83   bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
  84
  85   /* OpenGL ES 2.0 */
  86
  87   inline void ActiveTexture(GLenum textureUnit) override
  88   {
  89     mActiveTextureUnit = textureUnit - GL_TEXTURE0;
  90   }
  91
  92   inline GLenum GetActiveTextureUnit() const
  93   {
  94     return mActiveTextureUnit + GL_TEXTURE0;
  95   }
  96
  97   inline void AttachShader(GLuint program, GLuint shader) override
  98   {
  99     std::stringstream out;
 100     out << program << ", " << shader;
 101
 102     TraceCallStack::NamedParams namedParams;
 103     namedParams["program"] << program;
 104     namedParams["shader"] << shader;
 105     mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
 106   }
 107
 108   inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
 109   {
 110   }
 111
 112   inline void BindBuffer(GLenum target, GLuint buffer) override
 113   {
 114     std::ostringstream o;
 115     o << std::hex << target << ", " << buffer;
 116     TraceCallStack::NamedParams namedParams;
 117     namedParams["target"] << target;
 118     namedParams["buffer"] << buffer;
 119     mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
 120   }
 121
 122   inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
 123   {
 124     //Add 010 bit;
 125     mFramebufferStatus |= 2;
 126   }
 127
 128   inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
 129   {
 130   }
 131
 132   /**
 133    * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
 134    * @return A vector containing the IDs that were bound.
 135    */
 136   inline const std::vector<GLuint>& GetBoundTextures() const
 137   {
 138     return mBoundTextures;
 139   }
 140
 141   /**
 142    * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
 143    * @param[in] activeTextureUnit The specific active texture unit.
 144    * @return A vector containing the IDs that were bound.
 145    */
 146   inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
 147   {
 148     return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
 149   }
 150
 151   /**
 152    * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
 153    */
 154   inline void ClearBoundTextures()
 155   {
 156     mBoundTextures.clear();
 157
 158     for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
 159     {
 160       mActiveTextures[i].mBoundTextures.clear();
 161     }
 162   }
 163
 164   inline void BindTexture(GLenum target, GLuint texture) override
 165   {
 166     // Record the bound textures for future checks
 167     if(texture)
 168     {
 169       mBoundTextures.push_back(texture);
 170
 171       if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
 172       {
 173         mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
 174       }
 175     }
 176
 177     std::stringstream out;
 178     out << std::hex << target << ", " << std::dec << texture;
 179
 180     TraceCallStack::NamedParams namedParams;
 181     namedParams["target"] << std::hex << target;
 182     namedParams["texture"] << texture;
 183
 184     mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
 185   }
 186
 187   inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
 188   {
 189     mLastBlendColor.r = red;
 190     mLastBlendColor.g = green;
 191     mLastBlendColor.b = blue;
 192     mLastBlendColor.a = alpha;
 193   }
 194
 195   inline const Vector4& GetLastBlendColor() const
 196   {
 197     return mLastBlendColor;
 198   }
 199
 200   inline void BlendEquation(GLenum mode) override
 201   {
 202     mLastBlendEquationRgb   = mode;
 203     mLastBlendEquationAlpha = mode;
 204   }
 205
 206   inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
 207   {
 208     mLastBlendEquationRgb   = modeRgb;
 209     mLastBlendEquationAlpha = modeAlpha;
 210   }
 211
 212   inline GLenum GetLastBlendEquationRgb() const
 213   {
 214     return mLastBlendEquationRgb;
 215   }
 216
 217   inline GLenum GetLastBlendEquationAlpha() const
 218   {
 219     return mLastBlendEquationAlpha;
 220   }
 221
 222   inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
 223   {
 224     mLastBlendFuncSrcRgb   = sfactor;
 225     mLastBlendFuncDstRgb   = dfactor;
 226     mLastBlendFuncSrcAlpha = sfactor;
 227     mLastBlendFuncDstAlpha = dfactor;
 228   }
 229
 230   inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
 231   {
 232     mLastBlendFuncSrcRgb   = srcRGB;
 233     mLastBlendFuncDstRgb   = dstRGB;
 234     mLastBlendFuncSrcAlpha = srcAlpha;
 235     mLastBlendFuncDstAlpha = dstAlpha;
 236   }
 237
 238   inline GLenum GetLastBlendFuncSrcRgb() const
 239   {
 240     return mLastBlendFuncSrcRgb;
 241   }
 242
 243   inline GLenum GetLastBlendFuncDstRgb() const
 244   {
 245     return mLastBlendFuncDstRgb;
 246   }
 247
 248   inline GLenum GetLastBlendFuncSrcAlpha() const
 249   {
 250     return mLastBlendFuncSrcAlpha;
 251   }
 252
 253   inline GLenum GetLastBlendFuncDstAlpha() const
 254   {
 255     return mLastBlendFuncDstAlpha;
 256   }
 257
 258   inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
 259   {
 260     std::ostringstream o;
 261     o << std::hex << target << ", " << size << ", " << data << ", " << usage;
 262     TraceCallStack::NamedParams namedParams;
 263     namedParams["target"] << std::hex << target;
 264     namedParams["size"] << size;
 265     namedParams["usage"] << usage;
 266
 267     mBufferTrace.PushCall("BufferData", o.str(), namedParams);
 268
 269     mBufferDataCalls.push_back(size);
 270   }
 271
 272   inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
 273   {
 274     std::ostringstream o;
 275     o << std::hex << target << ", " << offset << ", " << size << ", " << data;
 276     TraceCallStack::NamedParams namedParams;
 277     namedParams["target"] << std::hex << target;
 278     namedParams["offset"] << offset;
 279     namedParams["size"] << size;
 280     mBufferTrace.PushCall("BufferSubData", o.str());
 281
 282     mBufferSubDataCalls.push_back(size);
 283   }
 284
 285   inline GLenum CheckFramebufferStatus(GLenum target) override
 286   {
 287     //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
 288     //Framebuffer texture have been called
 289     if(mFramebufferStatus == 7)
 290     {
 291       return GL_FRAMEBUFFER_COMPLETE;
 292     }
 293
 294     return mCheckFramebufferStatusResult;
 295   }
 296
 297   inline GLuint CheckFramebufferColorAttachmentCount()
 298   {
 299     return mFramebufferColorAttachmentCount;
 300   }
 301
 302   inline GLenum CheckFramebufferDepthAttachment()
 303   {
 304     return mFramebufferDepthAttached;
 305   }
 306
 307   inline GLenum CheckFramebufferStencilAttachment()
 308   {
 309     return mFramebufferStencilAttached;
 310   }
 311
 312   inline void Clear(GLbitfield mask) override
 313   {
 314     mClearCount++;
 315     mLastClearBitMask = mask;
 316   }
 317
 318   inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
 319   {
 320     mLastClearColor.r = red;
 321     mLastClearColor.g = green;
 322     mLastClearColor.b = blue;
 323     mLastClearColor.a = alpha;
 324   }
 325
 326   inline const Vector4& GetLastClearColor() const
 327   {
 328     return mLastClearColor;
 329   }
 330
 331   inline void ClearDepthf(GLclampf depth) override
 332   {
 333   }
 334
 335   inline void ClearStencil(GLint s) override
 336   {
 337     std::stringstream out;
 338     out << s;
 339
 340     TraceCallStack::NamedParams namedParams;
 341     namedParams["s"] << s;
 342
 343     mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
 344   }
 345
 346   inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
 347   {
 348     mColorMaskParams.red   = red;
 349     mColorMaskParams.green = green;
 350     mColorMaskParams.blue  = blue;
 351     mColorMaskParams.alpha = alpha;
 352   }
 353
 354   inline void CompileShader(GLuint shader) override
 355   {
 356     std::stringstream out;
 357     out << shader;
 358     TraceCallStack::NamedParams namedParams;
 359     namedParams["shader"] << shader;
 360
 361     mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
 362   }
 363
 364   inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
 365   {
 366     std::stringstream out;
 367     out << target << ", " << level << ", " << width << ", " << height;
 368
 369     TraceCallStack::NamedParams namedParams;
 370     namedParams["target"] << std::hex << target;
 371     namedParams["level"] << level;
 372     namedParams["internalformat"] << internalformat;
 373     namedParams["width"] << width;
 374     namedParams["height"] << height;
 375     namedParams["border"] << border;
 376     namedParams["size"] << imageSize;
 377
 378     mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
 379   }
 380
 381   inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
 382   {
 383     std::stringstream out;
 384     out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
 385
 386     TraceCallStack::NamedParams namedParams;
 387     namedParams["target"] << std::hex << target;
 388     namedParams["level"] << level;
 389     namedParams["xoffset"] << xoffset;
 390     namedParams["yoffset"] << yoffset;
 391     namedParams["width"] << width;
 392     namedParams["height"] << height;
 393     mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
 394   }
 395
 396   inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
 397   {
 398   }
 399
 400   inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
 401   {
 402   }
 403
 404   inline GLuint CreateProgram(void) override
 405   {
 406     mShaderTrace.PushCall("CreateProgram", "");
 407
 408     ++mLastProgramIdUsed;
 409     mUniforms[mLastProgramIdUsed] = UniformIDMap();
 410     return mLastProgramIdUsed;
 411   }
 412
 413   inline GLuint CreateShader(GLenum type) override
 414   {
 415     std::stringstream out;
 416     out << type;
 417
 418     TraceCallStack::NamedParams namedParams;
 419     namedParams["type"] << std::hex << type;
 420     mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
 421
 422     return ++mLastShaderIdUsed;
 423   }
 424
 425   inline void CullFace(GLenum mode) override
 426   {
 427     std::stringstream out;
 428     out << std::hex << mode;
 429
 430     TraceCallStack::NamedParams namedParams;
 431     namedParams["mode"] << std::hex << mode;
 432
 433     mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
 434   }
 435
 436   inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
 437   {
 438   }
 439
 440   inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
 441   {
 442   }
 443
 444   inline void DeleteProgram(GLuint program) override
 445   {
 446     std::stringstream out;
 447     out << program;
 448
 449     TraceCallStack::NamedParams namedParams;
 450     namedParams["program"] << program;
 451
 452     mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
 453   }
 454
 455   inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
 456   {
 457   }
 458
 459   inline void DeleteShader(GLuint shader) override
 460   {
 461     std::stringstream out;
 462     out << shader;
 463
 464     TraceCallStack::NamedParams namedParams;
 465     namedParams["shader"] << shader;
 466
 467     mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
 468   }
 469
 470   inline void DeleteTextures(GLsizei n, const GLuint* textures) override
 471   {
 472     std::stringstream out;
 473     out << "n:" << n << " textures[";
 474
 475     TraceCallStack::NamedParams namedParams;
 476
 477     for(GLsizei i = 0; i < n; i++)
 478     {
 479       out << (i > 0 ? ", " : "") << textures[i];
 480       std::stringstream paramName;
 481       paramName << "texture[" << i << "]";
 482       namedParams[paramName.str()] << textures[i];
 483       mDeletedTextureIds.push_back(textures[i]);
 484       mNumGeneratedTextures--;
 485     }
 486     out << "]";
 487
 488     mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
 489   }
 490
 491   inline bool CheckNoTexturesDeleted()
 492   {
 493     return mDeletedTextureIds.size() == 0;
 494   }
 495
 496   inline bool CheckTextureDeleted(GLuint textureId)
 497   {
 498     bool found = false;
 499
 500     for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
 501     {
 502       if(*iter == textureId)
 503       {
 504         found = true;
 505         break;
 506       }
 507     }
 508     return found;
 509   }
 510
 511   inline void ClearDeletedTextures()
 512   {
 513     mDeletedTextureIds.clear();
 514   }
 515
 516   inline void DepthFunc(GLenum func) override
 517   {
 518     std::stringstream out;
 519     out << std::hex << func;
 520
 521     TraceCallStack::NamedParams namedParams;
 522     namedParams["func"] << std::hex << func;
 523
 524     mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
 525   }
 526
 527   inline void DepthMask(GLboolean flag) override
 528   {
 529     mLastDepthMask = flag;
 530   }
 531
 532   inline bool GetLastDepthMask() const
 533   {
 534     return mLastDepthMask;
 535   }
 536
 537   inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
 538   {
 539   }
 540
 541   inline void DetachShader(GLuint program, GLuint shader) override
 542   {
 543     std::stringstream out;
 544     out << program << ", " << shader;
 545     TraceCallStack::NamedParams namedParams;
 546     namedParams["program"] << program;
 547     namedParams["shader"] << shader;
 548     mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
 549   }
 550
 551   inline void Disable(GLenum cap) override
 552   {
 553     std::stringstream out;
 554     out << std::hex << cap;
 555     TraceCallStack::NamedParams namedParams;
 556     namedParams["cap"] << std::hex << cap;
 557     mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
 558   }
 559
 560   inline void DisableVertexAttribArray(GLuint index) override
 561   {
 562     std::stringstream out;
 563     out << index;
 564     TraceCallStack::NamedParams namedParams;
 565     namedParams["index"] << index;
 566     mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
 567     SetVertexAttribArray(index, false);
 568   }
 569
 570   inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
 571   {
 572     std::stringstream out;
 573     out << mode << ", " << first << ", " << count;
 574     TraceCallStack::NamedParams namedParams;
 575     namedParams["mode"] << std::hex << mode;
 576     namedParams["first"] << first;
 577     namedParams["count"] << count;
 578     mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
 579   }
 580
 581   inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
 582   {
 583     std::stringstream out;
 584     out << mode << ", " << count << ", " << type << ", indices";
 585
 586     TraceCallStack::NamedParams namedParams;
 587     namedParams["mode"] << std::hex << mode;
 588     namedParams["count"] << count;
 589     namedParams["type"] << type;
 590     // Skip void pointers - are they of any use?
 591     mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
 592   }
 593
 594   inline void Enable(GLenum cap) override
 595   {
 596     std::stringstream out;
 597     out << std::hex << cap;
 598     TraceCallStack::NamedParams namedParams;
 599     namedParams["cap"] << std::hex << cap;
 600     mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
 601   }
 602
 603   inline void EnableVertexAttribArray(GLuint index) override
 604   {
 605     std::stringstream out;
 606     out << index;
 607     TraceCallStack::NamedParams namedParams;
 608     namedParams["index"] << index;
 609     mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
 610     SetVertexAttribArray(index, true);
 611   }
 612
 613   inline void Finish(void) override
 614   {
 615   }
 616
 617   inline void Flush(void) override
 618   {
 619   }
 620
 621   inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
 622   {
 623     if(attachment == GL_DEPTH_ATTACHMENT)
 624     {
 625       mFramebufferDepthAttached = true;
 626     }
 627     else if(attachment == GL_STENCIL_ATTACHMENT)
 628     {
 629       mFramebufferStencilAttached = true;
 630     }
 631     else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
 632     {
 633       mFramebufferStencilAttached = true;
 634       mFramebufferDepthAttached   = true;
 635     }
 636   }
 637
 638   inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
 639   {
 640     //Add 100 bit;
 641     mFramebufferStatus |= 4;
 642
 643     //We check 4 attachment colors
 644     if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
 645     {
 646       uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
 647       if((mFrameBufferColorStatus & mask) == 0)
 648       {
 649         mFrameBufferColorStatus |= mask;
 650         ++mFramebufferColorAttachmentCount;
 651       }
 652     }
 653   }
 654
 655   inline void FrontFace(GLenum mode) override
 656   {
 657     // do nothing
 658   }
 659
 660   inline void GenBuffers(GLsizei n, GLuint* buffers) override
 661   {
 662     // avoids an assert in GpuBuffers
 663     *buffers = 1u;
 664
 665     std::ostringstream o;
 666     o << n;
 667     TraceCallStack::NamedParams namedParams;
 668     namedParams["n"] << o.str();
 669     mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
 670   }
 671
 672   inline void GenerateMipmap(GLenum target) override
 673   {
 674     std::stringstream out;
 675     out << target;
 676     TraceCallStack::NamedParams namedParams;
 677     namedParams["target"] << std::hex << target;
 678
 679     mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
 680   }
 681
 682   inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
 683   {
 684     for(int i = 0; i < n; i++)
 685     {
 686       framebuffers[i] = i + 1;
 687     }
 688
 689     //Add 001 bit, this function needs to be called the first one in the chain
 690     mFramebufferStatus = 1;
 691   }
 692
 693   inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
 694   {
 695     for(int i = 0; i < n; i++)
 696     {
 697       renderbuffers[i] = i + 1;
 698     }
 699   }
 700
 701   /**
 702    * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
 703    * @param[in] ids A vector containing the next IDs to be generated
 704    */
 705   inline void SetNextTextureIds(const std::vector<GLuint>& ids)
 706   {
 707     mNextTextureIds = ids;
 708   }
 709
 710   inline const std::vector<GLuint>& GetNextTextureIds()
 711   {
 712     return mNextTextureIds;
 713   }
 714
 715   inline void GenTextures(GLsizei count, GLuint* textures) override
 716   {
 717     for(int i = 0; i < count; ++i)
 718     {
 719       if(!mNextTextureIds.empty())
 720       {
 721         *(textures + i) = mNextTextureIds[0];
 722         mNextTextureIds.erase(mNextTextureIds.begin());
 723       }
 724       else
 725       {
 726         *(textures + i) = ++mLastAutoTextureIdUsed;
 727       }
 728       mNumGeneratedTextures++;
 729     }
 730
 731     TraceCallStack::NamedParams namedParams;
 732     namedParams["count"] << count;
 733
 734     std::stringstream out;
 735     for(int i = 0; i < count; i++)
 736     {
 737       out << textures[i];
 738       if(i < count - 1)
 739       {
 740         out << ", ";
 741       }
 742       std::ostringstream oss;
 743       oss << "indices[" << i << "]";
 744       namedParams[oss.str()] << textures[i];
 745     }
 746
 747     mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
 748   }
 749
 750   inline GLuint GetLastGenTextureId()
 751   {
 752     return mLastAutoTextureIdUsed;
 753   }
 754
 755   inline GLuint GetNumGeneratedTextures()
 756   {
 757     return mNumGeneratedTextures;
 758   }
 759
 760   inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
 761   {
 762   }
 763
 764   inline void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms)
 765   {
 766     mActiveUniforms = uniforms;
 767   }
 768
 769   inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
 770   {
 771     if(index < mActiveUniforms.size())
 772     {
 773       *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
 774       *type   = mActiveUniforms[index].type;
 775       *size   = mActiveUniforms[index].size;
 776     }
 777   }
 778
 779   inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
 780   {
 781   }
 782
 783   inline int GetAttribLocation(GLuint program, const char* name) override
 784   {
 785     std::string check(name);
 786     auto        iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
 787     if(iter == mAttribLocs.end())
 788       return -1;
 789     return iter - mAttribLocs.begin();
 790   }
 791
 792   inline void GetBooleanv(GLenum pname, GLboolean* params) override
 793   {
 794   }
 795
 796   inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
 797   {
 798   }
 799
 800   inline GLenum GetError(void) override
 801   {
 802     return mGetErrorResult;
 803   }
 804
 805   inline void GetFloatv(GLenum pname, GLfloat* params) override
 806   {
 807   }
 808
 809   inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
 810   {
 811   }
 812
 813   inline void GetIntegerv(GLenum pname, GLint* params) override
 814   {
 815     switch(pname)
 816     {
 817       case GL_MAX_TEXTURE_SIZE:
 818         *params = 2048;
 819         break;
 820       case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
 821         *params = 8;
 822         break;
 823       case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
 824         *params = mNumBinaryFormats;
 825         break;
 826       case GL_PROGRAM_BINARY_FORMATS_OES:
 827         *params = mBinaryFormats;
 828         break;
 829     }
 830   }
 831
 832   inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
 833   {
 834     switch(pname)
 835     {
 836       case GL_LINK_STATUS:
 837         *params = mLinkStatus;
 838         break;
 839       case GL_PROGRAM_BINARY_LENGTH_OES:
 840         *params = mProgramBinaryLength;
 841         break;
 842       case GL_ACTIVE_UNIFORMS:
 843         *params = mActiveUniforms.size();
 844         break;
 845       case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 846         *params = 100;
 847         break;
 848       case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 849         *params = 100;
 850         break;
 851     }
 852   }
 853
 854   inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
 855   {
 856   }
 857
 858   inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
 859   {
 860   }
 861
 862   inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
 863   {
 864     switch(pname)
 865     {
 866       case GL_COMPILE_STATUS:
 867         *params = mCompileStatus;
 868         break;
 869     }
 870   }
 871
 872   inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
 873   {
 874   }
 875
 876   inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
 877   {
 878   }
 879
 880   inline const GLubyte* GetString(GLenum name) override
 881   {
 882     return mGetStringResult;
 883   }
 884
 885   inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
 886   {
 887   }
 888
 889   inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
 890   {
 891   }
 892
 893   inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
 894   {
 895   }
 896
 897   inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
 898   {
 899   }
 900
 901   inline GLint GetUniformLocation(GLuint program, const char* name) override
 902   {
 903     ProgramUniformMap::iterator it = mUniforms.find(program);
 904     if(it == mUniforms.end())
 905     {
 906       // Not a valid program ID
 907       mGetErrorResult = GL_INVALID_OPERATION;
 908       return -1;
 909     }
 910
 911     UniformIDMap&          uniformIDs = it->second;
 912     UniformIDMap::iterator it2        = uniformIDs.find(name);
 913     if(it2 == uniformIDs.end())
 914     {
 915       // Uniform not found, so add it...
 916       uniformIDs[name] = mLastUniformIdUsed++;
 917       return mLastUniformIdUsed;
 918     }
 919
 920     return it2->second;
 921   }
 922
 923   inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
 924   {
 925   }
 926
 927   inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
 928   {
 929   }
 930
 931   inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
 932   {
 933   }
 934
 935   inline void Hint(GLenum target, GLenum mode) override
 936   {
 937   }
 938
 939   inline GLboolean IsBuffer(GLuint buffer) override
 940   {
 941     return mIsBufferResult;
 942   }
 943
 944   inline GLboolean IsEnabled(GLenum cap) override
 945   {
 946     return mIsEnabledResult;
 947   }
 948
 949   inline GLboolean IsFramebuffer(GLuint framebuffer) override
 950   {
 951     return mIsFramebufferResult;
 952   }
 953
 954   inline GLboolean IsProgram(GLuint program) override
 955   {
 956     return mIsProgramResult;
 957   }
 958
 959   inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
 960   {
 961     return mIsRenderbufferResult;
 962   }
 963
 964   inline GLboolean IsShader(GLuint shader) override
 965   {
 966     return mIsShaderResult;
 967   }
 968
 969   inline GLboolean IsTexture(GLuint texture) override
 970   {
 971     return mIsTextureResult;
 972   }
 973
 974   inline void LineWidth(GLfloat width) override
 975   {
 976   }
 977
 978   inline void LinkProgram(GLuint program) override
 979   {
 980     std::stringstream out;
 981     out << program;
 982
 983     TraceCallStack::NamedParams namedParams;
 984     namedParams["program"] << program;
 985     mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
 986
 987     for(const auto& uniform : mActiveUniforms)
 988     {
 989       GetUniformLocation(program, uniform.name.c_str());
 990     }
 991
 992     for(const auto& uniform : mCustomUniformData)
 993     {
 994       GetUniformLocation(program, uniform.name.c_str());
 995     }
 996   }
 997
 998   inline void PixelStorei(GLenum pname, GLint param) override
 999   {
1000   }
1001
1002   inline void PolygonOffset(GLfloat factor, GLfloat units) override
1003   {
1004   }
1005
1006   inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1007   {
1008   }
1009
1010   inline void ReleaseShaderCompiler(void) override
1011   {
1012   }
1013
1014   inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1015   {
1016   }
1017
1018   inline void SampleCoverage(GLclampf value, GLboolean invert) override
1019   {
1020   }
1021
1022   inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1023   {
1024     mScissorParams.x      = x;
1025     mScissorParams.y      = y;
1026     mScissorParams.width  = width;
1027     mScissorParams.height = height;
1028
1029     std::stringstream out;
1030     out << x << ", " << y << ", " << width << ", " << height;
1031     TraceCallStack::NamedParams namedParams;
1032     namedParams["x"] << x;
1033     namedParams["y"] << y;
1034     namedParams["width"] << width;
1035     namedParams["height"] << height;
1036     mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1037   }
1038
1039   inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1040   {
1041   }
1042
1043   inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1044   {
1045     std::string stringBuilder;
1046     for(int i = 0; i < count; ++i)
1047     {
1048       stringBuilder += string[i];
1049     }
1050     mShaderSources[shader] = stringBuilder;
1051     mLastShaderCompiled    = shader;
1052   }
1053
1054   inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1055   {
1056     const std::string shaderSource       = mShaderSources[shader];
1057     const int         shaderSourceLength = static_cast<int>(shaderSource.length());
1058     if(shaderSourceLength < bufsize)
1059     {
1060       strncpy(source, shaderSource.c_str(), shaderSourceLength);
1061       *length = shaderSourceLength;
1062     }
1063     else
1064     {
1065       *length = bufsize - 1;
1066       strncpy(source, shaderSource.c_str(), *length);
1067       source[*length] = 0x0;
1068     }
1069   }
1070
1071   inline std::string GetShaderSource(GLuint shader)
1072   {
1073     return mShaderSources[shader];
1074   }
1075
1076   inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1077   {
1078     std::stringstream out;
1079     out << func << ", " << ref << ", " << mask;
1080
1081     TraceCallStack::NamedParams namedParams;
1082     namedParams["func"] << std::hex << func;
1083     namedParams["ref"] << ref;
1084     namedParams["mask"] << mask;
1085
1086     mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1087   }
1088
1089   inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1090   {
1091     std::stringstream out;
1092     out << face << ", " << func << ", " << ref << ", " << mask;
1093
1094     TraceCallStack::NamedParams namedParams;
1095     namedParams["face"] << std::hex << face;
1096     namedParams["func"] << std::hex << func;
1097     namedParams["ref"] << ref;
1098     namedParams["mask"] << mask;
1099
1100     mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1101   }
1102
1103   inline void StencilMask(GLuint mask) override
1104   {
1105     std::stringstream out;
1106     out << mask;
1107
1108     TraceCallStack::NamedParams namedParams;
1109     namedParams["mask"] << mask;
1110
1111     mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1112   }
1113
1114   inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1115   {
1116     std::stringstream out;
1117     out << face << ", " << mask;
1118
1119     TraceCallStack::NamedParams namedParams;
1120     namedParams["face"] << std::hex << face;
1121     namedParams["mask"] << mask;
1122
1123     mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1124   }
1125
1126   inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1127   {
1128     std::stringstream out;
1129     out << fail << ", " << zfail << ", " << zpass;
1130
1131     TraceCallStack::NamedParams namedParams;
1132     namedParams["fail"] << std::hex << fail;
1133     namedParams["zfail"] << std::hex << zfail;
1134     namedParams["zpass"] << std::hex << zpass;
1135
1136     mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1137   }
1138
1139   inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1140   {
1141     std::stringstream out;
1142     out << face << ", " << fail << ", " << zfail << "," << zpass;
1143
1144     TraceCallStack::NamedParams namedParams;
1145     namedParams["face"] << std::hex << face;
1146     namedParams["fail"] << std::hex << fail;
1147     namedParams["zfail"] << std::hex << zfail;
1148     namedParams["zpass"] << std::hex << zpass;
1149
1150     mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1151   }
1152
1153   inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1154   {
1155     std::stringstream out;
1156     out << target << ", " << level << ", " << width << ", " << height;
1157
1158     TraceCallStack::NamedParams namedParams;
1159     namedParams["target"] << std::hex << target;
1160     namedParams["level"] << level;
1161     namedParams["internalformat"] << internalformat;
1162     namedParams["width"] << width;
1163     namedParams["height"] << height;
1164     namedParams["border"] << border;
1165     namedParams["format"] << std::hex << format;
1166     namedParams["type"] << std::hex << type;
1167
1168     mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1169   }
1170
1171   inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1172   {
1173     std::stringstream out;
1174     out << target << ", " << pname << ", " << param;
1175
1176     TraceCallStack::NamedParams namedParams;
1177     namedParams["target"] << std::hex << target;
1178     namedParams["pname"] << std::hex << pname;
1179     namedParams["param"] << param;
1180
1181     mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1182   }
1183
1184   inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1185   {
1186     std::stringstream out;
1187     out << target << ", " << pname << ", " << params[0];
1188
1189     TraceCallStack::NamedParams namedParams;
1190     namedParams["target"] << std::hex << target;
1191     namedParams["pname"] << std::hex << pname;
1192     namedParams["params[0]"] << params[0];
1193
1194     mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1195   }
1196
1197   inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1198   {
1199     std::stringstream out;
1200     out << std::hex << target << ", " << pname << ", " << param;
1201     std::string params = out.str();
1202
1203     TraceCallStack::NamedParams namedParams;
1204     namedParams["target"] << std::hex << target;
1205     namedParams["pname"] << std::hex << pname;
1206     namedParams["param"] << param;
1207     mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1208   }
1209
1210   inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1211   {
1212     std::stringstream out;
1213     out << target << ", " << pname << ", " << params[0];
1214     TraceCallStack::NamedParams namedParams;
1215     namedParams["target"] << std::hex << target;
1216     namedParams["pname"] << std::hex << pname;
1217     namedParams["params[0]"] << params[0];
1218     mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1219   }
1220
1221   inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1222   {
1223     std::stringstream out;
1224     out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1225
1226     TraceCallStack::NamedParams namedParams;
1227     namedParams["target"] << std::hex << target;
1228     namedParams["level"] << level;
1229     namedParams["xoffset"] << xoffset;
1230     namedParams["yoffset"] << yoffset;
1231     namedParams["width"] << width;
1232     namedParams["height"] << height;
1233     mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1234   }
1235
1236   inline void Uniform1f(GLint location, GLfloat value) override
1237   {
1238     std::string params = std::to_string(value);
1239     AddUniformCallToTraceStack(location, params);
1240
1241     if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1242     {
1243       mGetErrorResult = GL_INVALID_OPERATION;
1244     }
1245   }
1246
1247   inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1248   {
1249     std::string params;
1250     for(int i = 0; i < count; ++i)
1251     {
1252       params = params + std::to_string(v[i]) + ",";
1253     }
1254
1255     AddUniformCallToTraceStack(location, params);
1256
1257     for(int i = 0; i < count; ++i)
1258     {
1259       if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1260       {
1261         mGetErrorResult = GL_INVALID_OPERATION;
1262         break;
1263       }
1264     }
1265   }
1266
1267   inline void Uniform1i(GLint location, GLint x) override
1268   {
1269     std::string params = std::to_string(x);
1270
1271     AddUniformCallToTraceStack(location, params);
1272
1273     if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1274     {
1275       mGetErrorResult = GL_INVALID_OPERATION;
1276     }
1277   }
1278
1279   inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1280   {
1281     std::ostringstream out;
1282     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1283     AddUniformCallToTraceStack(location, out.str());
1284
1285     for(int i = 0; i < count; ++i)
1286     {
1287       if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1288                                              location,
1289                                              v[i]))
1290       {
1291         mGetErrorResult = GL_INVALID_OPERATION;
1292         break;
1293       }
1294     }
1295   }
1296
1297   inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1298   {
1299     std::string params = std::to_string(x) + "," + std::to_string(y);
1300     AddUniformCallToTraceStack(location, params);
1301
1302     if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1303                                            location,
1304                                            Vector2(x, y)))
1305     {
1306       mGetErrorResult = GL_INVALID_OPERATION;
1307     }
1308   }
1309
1310   inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1311   {
1312     std::ostringstream out;
1313     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1314     AddUniformCallToTraceStack(location, out.str());
1315
1316     for(int i = 0; i < count; ++i)
1317     {
1318       if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1319                                              location,
1320                                              Vector2(v[2 * i], v[2 * i + 1])))
1321       {
1322         mGetErrorResult = GL_INVALID_OPERATION;
1323         break;
1324       }
1325     }
1326   }
1327
1328   inline void Uniform2i(GLint location, GLint x, GLint y) override
1329   {
1330     std::string params = std::to_string(x) + "," + std::to_string(y);
1331     AddUniformCallToTraceStack(location, params);
1332   }
1333
1334   inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1335   {
1336     std::ostringstream out;
1337     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1338     AddUniformCallToTraceStack(location, out.str());
1339   }
1340
1341   inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1342   {
1343     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1344     AddUniformCallToTraceStack(location, params);
1345
1346     if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1347                                            location,
1348                                            Vector3(x, y, z)))
1349     {
1350       mGetErrorResult = GL_INVALID_OPERATION;
1351     }
1352   }
1353
1354   inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1355   {
1356     std::ostringstream out;
1357     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1358     AddUniformCallToTraceStack(location, out.str());
1359
1360     for(int i = 0; i < count; ++i)
1361     {
1362       if(!mProgramUniforms3f.SetUniformValue(
1363            mCurrentProgram,
1364            location,
1365            Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1366       {
1367         mGetErrorResult = GL_INVALID_OPERATION;
1368         break;
1369       }
1370     }
1371   }
1372
1373   inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1374   {
1375     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1376     AddUniformCallToTraceStack(location, params);
1377   }
1378
1379   inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1380   {
1381     std::ostringstream out;
1382     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1383     AddUniformCallToTraceStack(location, out.str());
1384   }
1385
1386   inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1387   {
1388     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1389     AddUniformCallToTraceStack(location, params);
1390
1391     if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1392                                            location,
1393                                            Vector4(x, y, z, w)))
1394     {
1395       mGetErrorResult = GL_INVALID_OPERATION;
1396     }
1397   }
1398
1399   inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1400   {
1401     std::ostringstream out;
1402     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1403     AddUniformCallToTraceStack(location, out.str());
1404
1405     for(int i = 0; i < count; ++i)
1406     {
1407       if(!mProgramUniforms4f.SetUniformValue(
1408            mCurrentProgram,
1409            location,
1410            Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1411       {
1412         mGetErrorResult = GL_INVALID_OPERATION;
1413         break;
1414       }
1415     }
1416   }
1417
1418   inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1419   {
1420     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1421     AddUniformCallToTraceStack(location, params);
1422   }
1423
1424   inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1425   {
1426     std::ostringstream out;
1427     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1428     AddUniformCallToTraceStack(location, out.str());
1429   }
1430
1431   inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1432   {
1433     std::ostringstream out;
1434     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1435     AddUniformCallToTraceStack(location, out.str());
1436   }
1437
1438   inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1439   {
1440     std::ostringstream out;
1441     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1442     AddUniformCallToTraceStack(location, out.str());
1443
1444     for(int i = 0; i < count; ++i)
1445     {
1446       if(!mProgramUniformsMat3.SetUniformValue(
1447            mCurrentProgram,
1448            location,
1449            Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1450       {
1451         mGetErrorResult = GL_INVALID_OPERATION;
1452         break;
1453       }
1454     }
1455   }
1456
1457   inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1458   {
1459     std::ostringstream out;
1460     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1461     AddUniformCallToTraceStack(location, out.str());
1462
1463     for(int i = 0; i < count; ++i)
1464     {
1465       if(!mProgramUniformsMat4.SetUniformValue(
1466            mCurrentProgram,
1467            location,
1468            Matrix(value)))
1469       {
1470         mGetErrorResult = GL_INVALID_OPERATION;
1471         break;
1472       }
1473     }
1474   }
1475
1476   inline void UseProgram(GLuint program) override
1477   {
1478     mCurrentProgram = program;
1479   }
1480
1481   inline void ValidateProgram(GLuint program) override
1482   {
1483   }
1484
1485   inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1486   {
1487   }
1488
1489   inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1490   {
1491   }
1492
1493   inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1494   {
1495   }
1496
1497   inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1498   {
1499   }
1500
1501   inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1502   {
1503   }
1504
1505   inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1506   {
1507   }
1508
1509   inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1510   {
1511   }
1512
1513   inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1514   {
1515   }
1516
1517   inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1518   {
1519     TraceCallStack::NamedParams namedParams;
1520     namedParams["index"] << index;
1521     namedParams["size"] << size;
1522     namedParams["type"] << std::hex << type;
1523     namedParams["normalized"] << (normalized ? "T" : "F");
1524     namedParams["stride"] << stride;
1525     namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1526
1527     mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1528   }
1529
1530   inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1531   {
1532     std::string commaString(", ");
1533     std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1534
1535     mViewportTrace.PushCall("Viewport", params);
1536   }
1537
1538   /* OpenGL ES 3.0 */
1539
1540   inline void ReadBuffer(GLenum mode) override
1541   {
1542   }
1543
1544   inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1545   {
1546   }
1547
1548   inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) override
1549   {
1550   }
1551
1552   inline void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) override
1553   {
1554   }
1555
1556   inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1557   {
1558   }
1559
1560   inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1561   {
1562   }
1563
1564   inline void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) override
1565   {
1566   }
1567
1568   inline void GenQueries(GLsizei n, GLuint* ids) override
1569   {
1570   }
1571
1572   inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1573   {
1574   }
1575
1576   inline GLboolean IsQuery(GLuint id) override
1577   {
1578     return false;
1579   }
1580
1581   inline void BeginQuery(GLenum target, GLuint id) override
1582   {
1583   }
1584
1585   inline void EndQuery(GLenum target) override
1586   {
1587   }
1588
1589   inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1590   {
1591   }
1592
1593   inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1594   {
1595   }
1596
1597   inline GLboolean UnmapBuffer(GLenum target) override
1598   {
1599     if(mMappedBuffer)
1600     {
1601       free(mMappedBuffer);
1602       mMappedBuffer = nullptr;
1603     }
1604     return true; // false indicates corruption, nothing else.
1605   }
1606
1607   inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1608   {
1609   }
1610
1611   inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1612   {
1613   }
1614
1615   inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1616   {
1617   }
1618
1619   inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1620   {
1621   }
1622
1623   inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1624   {
1625   }
1626
1627   inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1628   {
1629   }
1630
1631   inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1632   {
1633   }
1634
1635   inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1636   {
1637   }
1638
1639   inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1640   {
1641   }
1642
1643   inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1644   {
1645   }
1646
1647   inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1648   {
1649   }
1650
1651   inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1652   {
1653     mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1654     return mMappedBuffer;
1655   }
1656
1657   inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1658   {
1659   }
1660
1661   inline void BindVertexArray(GLuint array) override
1662   {
1663   }
1664
1665   inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1666   {
1667   }
1668
1669   inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1670   {
1671   }
1672
1673   inline GLboolean IsVertexArray(GLuint array) override
1674   {
1675     return false;
1676   }
1677
1678   inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1679   {
1680   }
1681
1682   inline void BeginTransformFeedback(GLenum primitiveMode) override
1683   {
1684   }
1685
1686   inline void EndTransformFeedback(void) override
1687   {
1688   }
1689
1690   inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1691   {
1692   }
1693
1694   inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1695   {
1696   }
1697
1698   inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1699   {
1700   }
1701
1702   inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1703   {
1704   }
1705
1706   inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1707   {
1708   }
1709
1710   inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1711   {
1712   }
1713
1714   inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1715   {
1716   }
1717
1718   inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1719   {
1720   }
1721
1722   inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1723   {
1724   }
1725
1726   inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1727   {
1728   }
1729
1730   inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1731   {
1732   }
1733
1734   inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1735   {
1736   }
1737
1738   inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1739   {
1740     return -1;
1741   }
1742
1743   inline void Uniform1ui(GLint location, GLuint v0) override
1744   {
1745   }
1746
1747   inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1748   {
1749   }
1750
1751   inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1752   {
1753   }
1754
1755   inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1756   {
1757   }
1758
1759   inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1760   {
1761   }
1762
1763   inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1764   {
1765   }
1766
1767   inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1768   {
1769   }
1770
1771   inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1772   {
1773   }
1774
1775   inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1776   {
1777   }
1778
1779   inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1780   {
1781   }
1782
1783   inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1784   {
1785   }
1786
1787   inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1788   {
1789   }
1790
1791   inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1792   {
1793     return NULL;
1794   }
1795
1796   inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1797   {
1798   }
1799
1800   inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1801   {
1802   }
1803
1804   inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1805   {
1806   }
1807
1808   inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1809   {
1810     return GL_INVALID_INDEX;
1811   }
1812
1813   inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1814   {
1815   }
1816
1817   inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1818   {
1819   }
1820
1821   inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1822   {
1823   }
1824
1825   inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1826   {
1827   }
1828
1829   inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1830   {
1831   }
1832
1833   inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1834   {
1835     return NULL;
1836   }
1837
1838   inline GLboolean IsSync(GLsync sync) override
1839   {
1840     return false;
1841   }
1842
1843   inline void DeleteSync(GLsync sync) override
1844   {
1845   }
1846
1847   inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1848   {
1849     return 0;
1850   }
1851
1852   inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1853   {
1854   }
1855
1856   inline void GetInteger64v(GLenum pname, GLint64* params) override
1857   {
1858   }
1859
1860   inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1861   {
1862   }
1863
1864   inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1865   {
1866   }
1867
1868   inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1869   {
1870   }
1871
1872   inline void GenSamplers(GLsizei count, GLuint* samplers) override
1873   {
1874   }
1875
1876   inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1877   {
1878   }
1879
1880   inline GLboolean IsSampler(GLuint sampler) override
1881   {
1882     return false;
1883   }
1884
1885   inline void BindSampler(GLuint unit, GLuint sampler) override
1886   {
1887   }
1888
1889   inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1890   {
1891   }
1892
1893   inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1894   {
1895   }
1896
1897   inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1898   {
1899   }
1900
1901   inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1902   {
1903   }
1904
1905   inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1906   {
1907   }
1908
1909   inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1910   {
1911   }
1912
1913   inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1914   {
1915   }
1916
1917   inline void BindTransformFeedback(GLenum target, GLuint id) override
1918   {
1919   }
1920
1921   inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1922   {
1923   }
1924
1925   inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1926   {
1927   }
1928
1929   inline GLboolean IsTransformFeedback(GLuint id) override
1930   {
1931     return false;
1932   }
1933
1934   inline void PauseTransformFeedback(void) override
1935   {
1936   }
1937
1938   inline void ResumeTransformFeedback(void) override
1939   {
1940   }
1941
1942   inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1943   {
1944     mGetProgramBinaryCalled = true;
1945   }
1946
1947   inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1948   {
1949   }
1950
1951   inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1952   {
1953   }
1954
1955   inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1956   {
1957   }
1958
1959   inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1960   {
1961   }
1962
1963   inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1964   {
1965   }
1966
1967   inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1968   {
1969   }
1970
1971   inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1972   {
1973   }
1974
1975   inline void BlendBarrier(void)
1976   {
1977   }
1978
1979 private:
1980   inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1981   {
1982     std::string name    = "<not found>";
1983     bool        matched = false;
1984
1985     UniformIDMap& map = mUniforms[mCurrentProgram];
1986     for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1987     {
1988       if(it->second == location)
1989       {
1990         name    = it->first;
1991         matched = true;
1992         break;
1993       }
1994     }
1995
1996     if(matched)
1997     {
1998       mSetUniformTrace.PushCall(name, value);
1999     }
2000   }
2001
2002 public: // TEST FUNCTIONS
2003   inline void SetCompileStatus(GLuint value)
2004   {
2005     mCompileStatus = value;
2006   }
2007   inline void SetLinkStatus(GLuint value)
2008   {
2009     mLinkStatus = value;
2010   }
2011   inline void SetAttribLocations(std::vector<std::string> locs)
2012   {
2013     mAttribLocs = locs;
2014   }
2015   inline void SetGetErrorResult(GLenum result)
2016   {
2017     mGetErrorResult = result;
2018   }
2019   inline void SetGetStringResult(GLubyte* result)
2020   {
2021     mGetStringResult = result;
2022   }
2023   inline void SetIsBufferResult(GLboolean result)
2024   {
2025     mIsBufferResult = result;
2026   }
2027   inline void SetIsEnabledResult(GLboolean result)
2028   {
2029     mIsEnabledResult = result;
2030   }
2031   inline void SetIsFramebufferResult(GLboolean result)
2032   {
2033     mIsFramebufferResult = result;
2034   }
2035   inline void SetIsProgramResult(GLboolean result)
2036   {
2037     mIsProgramResult = result;
2038   }
2039   inline void SetIsRenderbufferResult(GLboolean result)
2040   {
2041     mIsRenderbufferResult = result;
2042   }
2043   inline void SetIsShaderResult(GLboolean result)
2044   {
2045     mIsShaderResult = result;
2046   }
2047   inline void SetIsTextureResult(GLboolean result)
2048   {
2049     mIsTextureResult = result;
2050   }
2051   inline void SetCheckFramebufferStatusResult(GLenum result)
2052   {
2053     mCheckFramebufferStatusResult = result;
2054   }
2055   inline void SetNumBinaryFormats(GLint numFormats)
2056   {
2057     mNumBinaryFormats = numFormats;
2058   }
2059   inline void SetBinaryFormats(GLint binaryFormats)
2060   {
2061     mBinaryFormats = binaryFormats;
2062   }
2063   inline void SetProgramBinaryLength(GLint length)
2064   {
2065     mProgramBinaryLength = length;
2066   }
2067
2068   inline bool GetVertexAttribArrayState(GLuint index)
2069   {
2070     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2071     {
2072       // out of range
2073       return false;
2074     }
2075     return mVertexAttribArrayState[index];
2076   }
2077   inline void ClearVertexAttribArrayChanged()
2078   {
2079     mVertexAttribArrayChanged = false;
2080   }
2081   inline bool GetVertexAttribArrayChanged()
2082   {
2083     return mVertexAttribArrayChanged;
2084   }
2085
2086   //Methods for CullFace verification
2087   inline void EnableCullFaceCallTrace(bool enable)
2088   {
2089     mCullFaceTrace.Enable(enable);
2090   }
2091   inline void ResetCullFaceCallStack()
2092   {
2093     mCullFaceTrace.Reset();
2094   }
2095   inline TraceCallStack& GetCullFaceTrace()
2096   {
2097     return mCullFaceTrace;
2098   }
2099
2100   //Methods for Enable/Disable call verification
2101   inline void EnableEnableDisableCallTrace(bool enable)
2102   {
2103     mEnableDisableTrace.Enable(enable);
2104   }
2105   inline void ResetEnableDisableCallStack()
2106   {
2107     mEnableDisableTrace.Reset();
2108   }
2109   inline TraceCallStack& GetEnableDisableTrace()
2110   {
2111     return mEnableDisableTrace;
2112   }
2113
2114   //Methods for Shader verification
2115   inline void EnableShaderCallTrace(bool enable)
2116   {
2117     mShaderTrace.Enable(enable);
2118   }
2119   inline void ResetShaderCallStack()
2120   {
2121     mShaderTrace.Reset();
2122   }
2123   inline TraceCallStack& GetShaderTrace()
2124   {
2125     return mShaderTrace;
2126   }
2127
2128   //Methods for Texture verification
2129   inline void EnableTextureCallTrace(bool enable)
2130   {
2131     mTextureTrace.Enable(enable);
2132   }
2133   inline void ResetTextureCallStack()
2134   {
2135     mTextureTrace.Reset();
2136   }
2137   inline TraceCallStack& GetTextureTrace()
2138   {
2139     return mTextureTrace;
2140   }
2141
2142   //Methods for Texture verification
2143   inline void EnableTexParameterCallTrace(bool enable)
2144   {
2145     mTexParameterTrace.Enable(enable);
2146   }
2147   inline void ResetTexParameterCallStack()
2148   {
2149     mTexParameterTrace.Reset();
2150   }
2151   inline TraceCallStack& GetTexParameterTrace()
2152   {
2153     return mTexParameterTrace;
2154   }
2155
2156   //Methods for Draw verification
2157   inline void EnableDrawCallTrace(bool enable)
2158   {
2159     mDrawTrace.Enable(enable);
2160   }
2161   inline void ResetDrawCallStack()
2162   {
2163     mDrawTrace.Reset();
2164   }
2165   inline TraceCallStack& GetDrawTrace()
2166   {
2167     return mDrawTrace;
2168   }
2169
2170   //Methods for Depth function verification
2171   inline void EnableDepthFunctionCallTrace(bool enable)
2172   {
2173     mDepthFunctionTrace.Enable(enable);
2174   }
2175   inline void ResetDepthFunctionCallStack()
2176   {
2177     mDepthFunctionTrace.Reset();
2178   }
2179   inline TraceCallStack& GetDepthFunctionTrace()
2180   {
2181     return mDepthFunctionTrace;
2182   }
2183
2184   //Methods for Stencil function verification
2185   inline void EnableStencilFunctionCallTrace(bool enable)
2186   {
2187     mStencilFunctionTrace.Enable(enable);
2188   }
2189   inline void ResetStencilFunctionCallStack()
2190   {
2191     mStencilFunctionTrace.Reset();
2192   }
2193   inline TraceCallStack& GetStencilFunctionTrace()
2194   {
2195     return mStencilFunctionTrace;
2196   }
2197
2198   //Methods for Scissor verification
2199   inline void EnableScissorCallTrace(bool enable)
2200   {
2201     mScissorTrace.Enable(enable);
2202   }
2203   inline void ResetScissorCallStack()
2204   {
2205     mScissorTrace.Reset();
2206   }
2207   inline TraceCallStack& GetScissorTrace()
2208   {
2209     return mScissorTrace;
2210   }
2211
2212   //Methods for Uniform function verification
2213   inline void EnableSetUniformCallTrace(bool enable)
2214   {
2215     mSetUniformTrace.Enable(enable);
2216   }
2217   inline void ResetSetUniformCallStack()
2218   {
2219     mSetUniformTrace.Reset();
2220   }
2221   inline TraceCallStack& GetSetUniformTrace()
2222   {
2223     return mSetUniformTrace;
2224   }
2225
2226   //Methods for Viewport verification
2227   inline void EnableViewportCallTrace(bool enable)
2228   {
2229     mViewportTrace.Enable(enable);
2230   }
2231   inline void ResetViewportCallStack()
2232   {
2233     mViewportTrace.Reset();
2234   }
2235   inline TraceCallStack& GetViewportTrace()
2236   {
2237     return mViewportTrace;
2238   }
2239   inline TraceCallStack& GetBufferTrace()
2240   {
2241     return mBufferTrace;
2242   }
2243
2244   template<typename T>
2245   inline bool GetUniformValue(const char* name, T& value) const
2246   {
2247     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2248         program_it != mUniforms.end();
2249         ++program_it)
2250     {
2251       const UniformIDMap& uniformIDs = program_it->second;
2252
2253       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2254       if(uniform_it != uniformIDs.end())
2255       {
2256         // found one matching uniform name, lets check the value...
2257         GLuint programId = program_it->first;
2258         GLint  uniformId = uniform_it->second;
2259
2260         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2261         return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2262       }
2263     }
2264     return false;
2265   }
2266
2267   template<typename T>
2268   inline bool CheckUniformValue(const char* name, const T& value) const
2269   {
2270     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2271         program_it != mUniforms.end();
2272         ++program_it)
2273     {
2274       const UniformIDMap& uniformIDs = program_it->second;
2275
2276       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2277       if(uniform_it != uniformIDs.end())
2278       {
2279         // found one matching uniform name, lets check the value...
2280         GLuint programId = program_it->first;
2281         GLint  uniformId = uniform_it->second;
2282
2283         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2284         if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2285         {
2286           // the value matches
2287           return true;
2288         }
2289       }
2290     }
2291
2292     fprintf(stderr, "%s Not found, printing possible values:\n", name);
2293     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2294         program_it != mUniforms.end();
2295         ++program_it)
2296     {
2297       const UniformIDMap& uniformIDs = program_it->second;
2298
2299       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2300       if(uniform_it != uniformIDs.end())
2301       {
2302         // found one matching uniform name, lets check the value...
2303         GLuint programId = program_it->first;
2304         GLint  uniformId = uniform_it->second;
2305
2306         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2307         T                             origValue;
2308         if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2309         {
2310           std::stringstream out;
2311           out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2312           fprintf(stderr, "%s\n", out.str().c_str());
2313         }
2314       }
2315     }
2316     return false;
2317   }
2318
2319   template<typename T>
2320   inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2321   {
2322     const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2323     return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2324   }
2325
2326   inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2327   {
2328     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2329         program_it != mUniforms.end();
2330         ++program_it)
2331     {
2332       const UniformIDMap& uniformIDs = program_it->second;
2333
2334       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2335       if(uniform_it != uniformIDs.end())
2336       {
2337         programId = program_it->first;
2338         uniformId = uniform_it->second;
2339         return true;
2340       }
2341     }
2342     return false;
2343   }
2344
2345   inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2346   {
2347     mCustomUniformData = customUniformData;
2348   }
2349
2350   inline GLuint GetLastShaderCompiled() const
2351   {
2352     return mLastShaderCompiled;
2353   }
2354
2355   inline GLuint GetLastProgramCreated() const
2356   {
2357     return mLastProgramIdUsed;
2358   }
2359
2360   inline GLbitfield GetLastClearMask() const
2361   {
2362     return mLastClearBitMask;
2363   }
2364
2365   enum AttribType
2366   {
2367     ATTRIB_UNKNOWN = -1,
2368     ATTRIB_POSITION,
2369     ATTRIB_NORMAL,
2370     ATTRIB_TEXCOORD,
2371     ATTRIB_COLOR,
2372     ATTRIB_BONE_WEIGHTS,
2373     ATTRIB_BONE_INDICES,
2374     ATTRIB_TYPE_LAST
2375   };
2376
2377   struct ScissorParams
2378   {
2379     GLint   x;
2380     GLint   y;
2381     GLsizei width;
2382     GLsizei height;
2383
2384     ScissorParams()
2385     : x(0),
2386       y(0),
2387       width(0),
2388       height(0)
2389     {
2390     }
2391   };
2392
2393   // Methods to check scissor tests
2394   inline const ScissorParams& GetScissorParams() const
2395   {
2396     return mScissorParams;
2397   }
2398
2399   struct ColorMaskParams
2400   {
2401     GLboolean red;
2402     GLboolean green;
2403     GLboolean blue;
2404     GLboolean alpha;
2405
2406     ColorMaskParams()
2407     : red(true),
2408       green(true),
2409       blue(true),
2410       alpha(true)
2411     {
2412     }
2413   };
2414
2415   inline bool GetProgramBinaryCalled() const
2416   {
2417     return mGetProgramBinaryCalled;
2418   }
2419
2420   inline unsigned int GetClearCountCalled() const
2421   {
2422     return mClearCount;
2423   }
2424
2425   inline const ColorMaskParams& GetColorMaskParams() const
2426   {
2427     return mColorMaskParams;
2428   }
2429
2430   typedef std::vector<size_t>   BufferDataCalls;
2431   inline const BufferDataCalls& GetBufferDataCalls() const
2432   {
2433     return mBufferDataCalls;
2434   }
2435   inline void ResetBufferDataCalls()
2436   {
2437     mBufferDataCalls.clear();
2438   }
2439
2440   typedef std::vector<size_t>      BufferSubDataCalls;
2441   inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2442   {
2443     return mBufferSubDataCalls;
2444   }
2445   inline void ResetBufferSubDataCalls()
2446   {
2447     mBufferSubDataCalls.clear();
2448   }
2449
2450 public:
2451   GLuint                                mCurrentProgram;
2452   GLuint                                mCompileStatus;
2453   BufferDataCalls                       mBufferDataCalls;
2454   BufferSubDataCalls                    mBufferSubDataCalls;
2455   GLvoid*                               mMappedBuffer{nullptr};
2456   GLuint                                mLinkStatus;
2457   GLenum                                mGetErrorResult;
2458   GLubyte*                              mGetStringResult;
2459   GLboolean                             mIsBufferResult;
2460   GLboolean                             mIsEnabledResult;
2461   GLboolean                             mIsFramebufferResult;
2462   GLboolean                             mIsProgramResult;
2463   GLboolean                             mIsRenderbufferResult;
2464   GLboolean                             mIsShaderResult;
2465   GLboolean                             mIsTextureResult;
2466   GLenum                                mActiveTextureUnit;
2467   GLenum                                mCheckFramebufferStatusResult;
2468   GLint                                 mFramebufferStatus;
2469   GLenum                                mFramebufferDepthAttached;
2470   GLenum                                mFramebufferStencilAttached;
2471   GLuint                                mFramebufferColorAttachmentCount;
2472   GLuint                                mFrameBufferColorStatus;
2473   GLint                                 mNumBinaryFormats;
2474   GLint                                 mBinaryFormats;
2475   GLint                                 mProgramBinaryLength;
2476   bool                                  mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2477   bool                                  mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2478   bool                                  mGetProgramBinaryCalled;
2479   typedef std::map<GLuint, std::string> ShaderSourceMap;
2480   ShaderSourceMap                       mShaderSources;
2481   std::vector<std::string>              mAttribLocs; // should be bound to shader
2482   GLuint                                mLastShaderCompiled;
2483   GLbitfield                            mLastClearBitMask;
2484   Vector4                               mLastClearColor;
2485   unsigned int                          mClearCount;
2486
2487   Vector4 mLastBlendColor;
2488   GLenum  mLastBlendEquationRgb;
2489   GLenum  mLastBlendEquationAlpha;
2490   GLenum  mLastBlendFuncSrcRgb;
2491   GLenum  mLastBlendFuncDstRgb;
2492   GLenum  mLastBlendFuncSrcAlpha;
2493   GLenum  mLastBlendFuncDstAlpha;
2494
2495   GLboolean mLastDepthMask;
2496
2497   // Data for manipulating the IDs returned by GenTextures
2498   GLuint              mLastAutoTextureIdUsed;
2499   GLuint              mNumGeneratedTextures;
2500   std::vector<GLuint> mNextTextureIds;
2501   std::vector<GLuint> mDeletedTextureIds;
2502   std::vector<GLuint> mBoundTextures;
2503
2504   struct ActiveTextureType
2505   {
2506     std::vector<GLuint> mBoundTextures;
2507   };
2508
2509   ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2510
2511   TraceCallStack mBufferTrace;
2512   TraceCallStack mCullFaceTrace;
2513   TraceCallStack mEnableDisableTrace;
2514   TraceCallStack mShaderTrace;
2515   TraceCallStack mTextureTrace;
2516   TraceCallStack mTexParameterTrace;
2517   TraceCallStack mDrawTrace;
2518   TraceCallStack mDepthFunctionTrace;
2519   TraceCallStack mStencilFunctionTrace;
2520   TraceCallStack mScissorTrace;
2521   TraceCallStack mSetUniformTrace;
2522   TraceCallStack mViewportTrace;
2523
2524   // Shaders & Uniforms
2525   GLuint                                 mLastShaderIdUsed;
2526   GLuint                                 mLastProgramIdUsed{0u};
2527   GLuint                                 mLastUniformIdUsed;
2528   typedef std::map<std::string, GLint>   UniformIDMap;
2529   typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2530   ProgramUniformMap                      mUniforms;
2531   std::vector<ActiveUniform>             mActiveUniforms;
2532   std::vector<UniformData>               mCustomUniformData{};
2533
2534   template<typename T>
2535   struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2536   {
2537   public:
2538     typedef std::map<GLint, T>                UniformValueMap;
2539     typedef std::map<GLuint, UniformValueMap> Map;
2540
2541     bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2542     {
2543       if(program == 0)
2544       {
2545         return false;
2546       }
2547
2548       typename Map::iterator it = Map::find(program);
2549       if(it == Map::end())
2550       {
2551         // if its the first uniform for this program add it
2552         std::pair<typename Map::iterator, bool> result =
2553           Map::insert(typename Map::value_type(program, UniformValueMap()));
2554         it = result.first;
2555       }
2556
2557       UniformValueMap& uniforms = it->second;
2558       uniforms[uniform]         = value;
2559
2560       return true;
2561     }
2562
2563     bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2564     {
2565       T uniformValue;
2566       if(GetUniformValue(program, uniform, uniformValue))
2567       {
2568         return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2569       }
2570
2571       return false;
2572     }
2573
2574     bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2575     {
2576       if(program == 0)
2577       {
2578         return false;
2579       }
2580
2581       typename Map::const_iterator it = Map::find(program);
2582       if(it == Map::end())
2583       {
2584         // Uniform values always initialised as 0
2585         value = GetZero();
2586         return true;
2587       }
2588
2589       const UniformValueMap&                   uniforms = it->second;
2590       typename UniformValueMap::const_iterator it2      = uniforms.find(uniform);
2591       if(it2 == uniforms.end())
2592       {
2593         // Uniform values always initialised as 0
2594         value = GetZero();
2595         return true;
2596       }
2597       value = it2->second;
2598
2599       return true;
2600     }
2601
2602     T GetZero() const;
2603   };
2604   ProgramUniformValue<int>     mProgramUniforms1i;
2605   ProgramUniformValue<float>   mProgramUniforms1f;
2606   ProgramUniformValue<Vector2> mProgramUniforms2f;
2607   ProgramUniformValue<Vector3> mProgramUniforms3f;
2608   ProgramUniformValue<Vector4> mProgramUniforms4f;
2609   ProgramUniformValue<Matrix>  mProgramUniformsMat4;
2610   ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2611
2612   inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2613   {
2614     return mProgramUniforms1i;
2615   }
2616   inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2617   {
2618     return mProgramUniforms1f;
2619   }
2620   inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2621   {
2622     return mProgramUniforms2f;
2623   }
2624   inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2625   {
2626     return mProgramUniforms3f;
2627   }
2628   inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2629   {
2630     return mProgramUniforms4f;
2631   }
2632   inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2633   {
2634     return mProgramUniformsMat4;
2635   }
2636   inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2637   {
2638     return mProgramUniformsMat3;
2639   }
2640   inline void SetVertexAttribArray(GLuint index, bool state)
2641   {
2642     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2643     {
2644       // out of range
2645       return;
2646     }
2647     mVertexAttribArrayState[index] = state;
2648     mVertexAttribArrayChanged      = true;
2649   }
2650
2651   ScissorParams   mScissorParams;
2652   ColorMaskParams mColorMaskParams;
2653 };
2654
2655 template<>
2656 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2657 {
2658   return 0;
2659 }
2660
2661 template<>
2662 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2663 {
2664   return 0.0f;
2665 }
2666
2667 template<>
2668 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2669 {
2670   return Vector2::ZERO;
2671 }
2672
2673 template<>
2674 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2675 {
2676   return Vector3::ZERO;
2677 }
2678
2679 template<>
2680 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2681 {
2682   return Vector4::ZERO;
2683 }
2684
2685 template<>
2686 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2687 {
2688   return Matrix();
2689 }
2690
2691 template<>
2692 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2693 {
2694   return Matrix3(Matrix());
2695 }
2696
2697 } // namespace Dali
2698
2699 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2700 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2701
2702 #endif // TEST_GL_ABSTRACTION_H