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