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