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