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   }
 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:" << n << " textures[";
 442
 443     TraceCallStack::NamedParams namedParams;
 444
 445     for(GLsizei i = 0; i < n; i++)
 446     {
 447       out << (i > 0 ? ", " : "") << 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 << std::hex << target << ", " << pname << ", " << param;
1155     std::string params = out.str();
1156
1157     out.str("");
1158     out << std::hex << target;
1159     TraceCallStack::NamedParams namedParams;
1160     namedParams["target"] = out.str();
1161     out.str("");
1162     out << std::hex << pname;
1163     namedParams["pname"] = out.str();
1164     out.str("");
1165     out << std::hex << param;
1166     namedParams["param"] = out.str();
1167     mTexParamaterTrace.PushCall("TexParameteri", params, namedParams);
1168   }
1169
1170   inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1171   {
1172     std::stringstream out;
1173     out << target << ", " << pname << ", " << params[0];
1174     TraceCallStack::NamedParams namedParams;
1175     namedParams["target"]    = ToString(target);
1176     namedParams["pname"]     = ToString(pname);
1177     namedParams["params[0]"] = ToString(params[0]);
1178     mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1179   }
1180
1181   inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1182   {
1183     std::stringstream out;
1184     out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1185
1186     TraceCallStack::NamedParams namedParams;
1187     namedParams["target"]  = ToString(target);
1188     namedParams["level"]   = ToString(level);
1189     namedParams["xoffset"] = ToString(xoffset);
1190     namedParams["yoffset"] = ToString(yoffset);
1191     namedParams["width"]   = ToString(width);
1192     namedParams["height"]  = ToString(height);
1193     mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1194   }
1195
1196   inline void Uniform1f(GLint location, GLfloat value) override
1197   {
1198     std::string params = ToString(value);
1199     AddUniformCallToTraceStack(location, params);
1200
1201     if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1202     {
1203       mGetErrorResult = GL_INVALID_OPERATION;
1204     }
1205   }
1206
1207   inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1208   {
1209     std::string params;
1210     for(int i = 0; i < count; ++i)
1211     {
1212       params = params + ToString(v[i]) + ",";
1213     }
1214
1215     AddUniformCallToTraceStack(location, params);
1216
1217     for(int i = 0; i < count; ++i)
1218     {
1219       if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1220       {
1221         mGetErrorResult = GL_INVALID_OPERATION;
1222         break;
1223       }
1224     }
1225   }
1226
1227   inline void Uniform1i(GLint location, GLint x) override
1228   {
1229     std::string params = ToString(x);
1230
1231     AddUniformCallToTraceStack(location, params);
1232
1233     if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1234     {
1235       mGetErrorResult = GL_INVALID_OPERATION;
1236     }
1237   }
1238
1239   inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1240   {
1241     std::string params = ToString(v);
1242     AddUniformCallToTraceStack(location, params);
1243
1244     for(int i = 0; i < count; ++i)
1245     {
1246       if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1247                                              location,
1248                                              v[i]))
1249       {
1250         mGetErrorResult = GL_INVALID_OPERATION;
1251         break;
1252       }
1253     }
1254   }
1255
1256   inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1257   {
1258     std::string params = ToString(x) + "," + ToString(y);
1259     AddUniformCallToTraceStack(location, params);
1260
1261     if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1262                                            location,
1263                                            Vector2(x, y)))
1264     {
1265       mGetErrorResult = GL_INVALID_OPERATION;
1266     }
1267   }
1268
1269   inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1270   {
1271     std::string params = ToString(v);
1272     AddUniformCallToTraceStack(location, params);
1273
1274     for(int i = 0; i < count; ++i)
1275     {
1276       if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1277                                              location,
1278                                              Vector2(v[2 * i], v[2 * i + 1])))
1279       {
1280         mGetErrorResult = GL_INVALID_OPERATION;
1281         break;
1282       }
1283     }
1284   }
1285
1286   inline void Uniform2i(GLint location, GLint x, GLint y) override
1287   {
1288     std::string params = ToString(x) + "," + ToString(y);
1289     AddUniformCallToTraceStack(location, params);
1290   }
1291
1292   inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1293   {
1294     std::string params = ToString(v);
1295     AddUniformCallToTraceStack(location, params);
1296   }
1297
1298   inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1299   {
1300     std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1301     AddUniformCallToTraceStack(location, params);
1302
1303     if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1304                                            location,
1305                                            Vector3(x, y, z)))
1306     {
1307       mGetErrorResult = GL_INVALID_OPERATION;
1308     }
1309   }
1310
1311   inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1312   {
1313     std::string params = ToString(v);
1314     AddUniformCallToTraceStack(location, params);
1315
1316     for(int i = 0; i < count; ++i)
1317     {
1318       if(!mProgramUniforms3f.SetUniformValue(
1319            mCurrentProgram,
1320            location,
1321            Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1322       {
1323         mGetErrorResult = GL_INVALID_OPERATION;
1324         break;
1325       }
1326     }
1327   }
1328
1329   inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1330   {
1331     std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1332     AddUniformCallToTraceStack(location, params);
1333   }
1334
1335   inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1336   {
1337     std::string params = ToString(v);
1338     AddUniformCallToTraceStack(location, params);
1339   }
1340
1341   inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1342   {
1343     std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1344     AddUniformCallToTraceStack(location, params);
1345
1346     if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1347                                            location,
1348                                            Vector4(x, y, z, w)))
1349     {
1350       mGetErrorResult = GL_INVALID_OPERATION;
1351     }
1352   }
1353
1354   inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1355   {
1356     std::string params = ToString(v);
1357     AddUniformCallToTraceStack(location, params);
1358
1359     for(int i = 0; i < count; ++i)
1360     {
1361       if(!mProgramUniforms4f.SetUniformValue(
1362            mCurrentProgram,
1363            location,
1364            Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1365       {
1366         mGetErrorResult = GL_INVALID_OPERATION;
1367         break;
1368       }
1369     }
1370   }
1371
1372   inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1373   {
1374     std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1375     AddUniformCallToTraceStack(location, params);
1376   }
1377
1378   inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1379   {
1380     std::string params = ToString(v);
1381     AddUniformCallToTraceStack(location, params);
1382   }
1383
1384   inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1385   {
1386     std::string params = ToString(value);
1387     AddUniformCallToTraceStack(location, params);
1388   }
1389
1390   inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1391   {
1392     std::string params = ToString(value);
1393     AddUniformCallToTraceStack(location, params);
1394
1395     for(int i = 0; i < count; ++i)
1396     {
1397       if(!mProgramUniformsMat3.SetUniformValue(
1398            mCurrentProgram,
1399            location,
1400            Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1401       {
1402         mGetErrorResult = GL_INVALID_OPERATION;
1403         break;
1404       }
1405     }
1406   }
1407
1408   inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1409   {
1410     std::string params = ToString(value);
1411     AddUniformCallToTraceStack(location, params);
1412
1413     for(int i = 0; i < count; ++i)
1414     {
1415       if(!mProgramUniformsMat4.SetUniformValue(
1416            mCurrentProgram,
1417            location,
1418            Matrix(value)))
1419       {
1420         mGetErrorResult = GL_INVALID_OPERATION;
1421         break;
1422       }
1423     }
1424   }
1425
1426   inline void UseProgram(GLuint program) override
1427   {
1428     mCurrentProgram = program;
1429   }
1430
1431   inline void ValidateProgram(GLuint program) override
1432   {
1433   }
1434
1435   inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1436   {
1437   }
1438
1439   inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1440   {
1441   }
1442
1443   inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1444   {
1445   }
1446
1447   inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1448   {
1449   }
1450
1451   inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1452   {
1453   }
1454
1455   inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1456   {
1457   }
1458
1459   inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1460   {
1461   }
1462
1463   inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1464   {
1465   }
1466
1467   inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1468   {
1469   }
1470
1471   inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1472   {
1473     std::string commaString(", ");
1474     std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1475
1476     mViewportTrace.PushCall("Viewport", params);
1477   }
1478
1479   /* OpenGL ES 3.0 */
1480
1481   inline void ReadBuffer(GLenum mode) override
1482   {
1483   }
1484
1485   inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1486   {
1487   }
1488
1489   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
1490   {
1491   }
1492
1493   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
1494   {
1495   }
1496
1497   inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1498   {
1499   }
1500
1501   inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1502   {
1503   }
1504
1505   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
1506   {
1507   }
1508
1509   inline void GenQueries(GLsizei n, GLuint* ids) override
1510   {
1511   }
1512
1513   inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1514   {
1515   }
1516
1517   inline GLboolean IsQuery(GLuint id) override
1518   {
1519     return false;
1520   }
1521
1522   inline void BeginQuery(GLenum target, GLuint id) override
1523   {
1524   }
1525
1526   inline void EndQuery(GLenum target) override
1527   {
1528   }
1529
1530   inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1531   {
1532   }
1533
1534   inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1535   {
1536   }
1537
1538   inline GLboolean UnmapBuffer(GLenum target) override
1539   {
1540     return false;
1541   }
1542
1543   inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1544   {
1545   }
1546
1547   inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1548   {
1549   }
1550
1551   inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1552   {
1553   }
1554
1555   inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1556   {
1557   }
1558
1559   inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1560   {
1561   }
1562
1563   inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1564   {
1565   }
1566
1567   inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1568   {
1569   }
1570
1571   inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1572   {
1573   }
1574
1575   inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1576   {
1577   }
1578
1579   inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1580   {
1581   }
1582
1583   inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1584   {
1585   }
1586
1587   inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1588   {
1589     return NULL;
1590   }
1591
1592   inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1593   {
1594   }
1595
1596   inline void BindVertexArray(GLuint array) override
1597   {
1598   }
1599
1600   inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1601   {
1602   }
1603
1604   inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1605   {
1606   }
1607
1608   inline GLboolean IsVertexArray(GLuint array) override
1609   {
1610     return false;
1611   }
1612
1613   inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1614   {
1615   }
1616
1617   inline void BeginTransformFeedback(GLenum primitiveMode) override
1618   {
1619   }
1620
1621   inline void EndTransformFeedback(void) override
1622   {
1623   }
1624
1625   inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1626   {
1627   }
1628
1629   inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1630   {
1631   }
1632
1633   inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1634   {
1635   }
1636
1637   inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1638   {
1639   }
1640
1641   inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1642   {
1643   }
1644
1645   inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1646   {
1647   }
1648
1649   inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1650   {
1651   }
1652
1653   inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1654   {
1655   }
1656
1657   inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1658   {
1659   }
1660
1661   inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1662   {
1663   }
1664
1665   inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1666   {
1667   }
1668
1669   inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1670   {
1671   }
1672
1673   inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1674   {
1675     return -1;
1676   }
1677
1678   inline void Uniform1ui(GLint location, GLuint v0) override
1679   {
1680   }
1681
1682   inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1683   {
1684   }
1685
1686   inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1687   {
1688   }
1689
1690   inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1691   {
1692   }
1693
1694   inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1695   {
1696   }
1697
1698   inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1699   {
1700   }
1701
1702   inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1703   {
1704   }
1705
1706   inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1707   {
1708   }
1709
1710   inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1711   {
1712   }
1713
1714   inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1715   {
1716   }
1717
1718   inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1719   {
1720   }
1721
1722   inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1723   {
1724   }
1725
1726   inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1727   {
1728     return NULL;
1729   }
1730
1731   inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1732   {
1733   }
1734
1735   inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1736   {
1737   }
1738
1739   inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1740   {
1741   }
1742
1743   inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1744   {
1745     return GL_INVALID_INDEX;
1746   }
1747
1748   inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1749   {
1750   }
1751
1752   inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1753   {
1754   }
1755
1756   inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1757   {
1758   }
1759
1760   inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1761   {
1762   }
1763
1764   inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1765   {
1766   }
1767
1768   inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1769   {
1770     return NULL;
1771   }
1772
1773   inline GLboolean IsSync(GLsync sync) override
1774   {
1775     return false;
1776   }
1777
1778   inline void DeleteSync(GLsync sync) override
1779   {
1780   }
1781
1782   inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1783   {
1784     return 0;
1785   }
1786
1787   inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1788   {
1789   }
1790
1791   inline void GetInteger64v(GLenum pname, GLint64* params) override
1792   {
1793   }
1794
1795   inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1796   {
1797   }
1798
1799   inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1800   {
1801   }
1802
1803   inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1804   {
1805   }
1806
1807   inline void GenSamplers(GLsizei count, GLuint* samplers) override
1808   {
1809   }
1810
1811   inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1812   {
1813   }
1814
1815   inline GLboolean IsSampler(GLuint sampler) override
1816   {
1817     return false;
1818   }
1819
1820   inline void BindSampler(GLuint unit, GLuint sampler) override
1821   {
1822   }
1823
1824   inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1825   {
1826   }
1827
1828   inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1829   {
1830   }
1831
1832   inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1833   {
1834   }
1835
1836   inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1837   {
1838   }
1839
1840   inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1841   {
1842   }
1843
1844   inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1845   {
1846   }
1847
1848   inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1849   {
1850   }
1851
1852   inline void BindTransformFeedback(GLenum target, GLuint id) override
1853   {
1854   }
1855
1856   inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1857   {
1858   }
1859
1860   inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1861   {
1862   }
1863
1864   inline GLboolean IsTransformFeedback(GLuint id) override
1865   {
1866     return false;
1867   }
1868
1869   inline void PauseTransformFeedback(void) override
1870   {
1871   }
1872
1873   inline void ResumeTransformFeedback(void) override
1874   {
1875   }
1876
1877   inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1878   {
1879     mGetProgramBinaryCalled = true;
1880   }
1881
1882   inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1883   {
1884   }
1885
1886   inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1887   {
1888   }
1889
1890   inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1891   {
1892   }
1893
1894   inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1895   {
1896   }
1897
1898   inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1899   {
1900   }
1901
1902   inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1903   {
1904   }
1905
1906   inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1907   {
1908   }
1909
1910   inline void BlendBarrier(void)
1911   {
1912   }
1913
1914 private:
1915   inline void AddUniformCallToTraceStack(GLint location, std::string& value)
1916   {
1917     std::string name    = "<not found>";
1918     bool        matched = false;
1919
1920     UniformIDMap& map = mUniforms[mCurrentProgram];
1921     for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1922     {
1923       if(it->second == location)
1924       {
1925         name    = it->first;
1926         matched = true;
1927         break;
1928       }
1929     }
1930
1931     if(matched)
1932     {
1933       mSetUniformTrace.PushCall(name, value);
1934     }
1935   }
1936
1937 public: // TEST FUNCTIONS
1938   inline void SetCompileStatus(GLuint value)
1939   {
1940     mCompileStatus = value;
1941   }
1942   inline void SetLinkStatus(GLuint value)
1943   {
1944     mLinkStatus = value;
1945   }
1946   inline void SetGetAttribLocationResult(int result)
1947   {
1948     mGetAttribLocationResult = result;
1949   }
1950   inline void SetGetErrorResult(GLenum result)
1951   {
1952     mGetErrorResult = result;
1953   }
1954   inline void SetGetStringResult(GLubyte* result)
1955   {
1956     mGetStringResult = result;
1957   }
1958   inline void SetIsBufferResult(GLboolean result)
1959   {
1960     mIsBufferResult = result;
1961   }
1962   inline void SetIsEnabledResult(GLboolean result)
1963   {
1964     mIsEnabledResult = result;
1965   }
1966   inline void SetIsFramebufferResult(GLboolean result)
1967   {
1968     mIsFramebufferResult = result;
1969   }
1970   inline void SetIsProgramResult(GLboolean result)
1971   {
1972     mIsProgramResult = result;
1973   }
1974   inline void SetIsRenderbufferResult(GLboolean result)
1975   {
1976     mIsRenderbufferResult = result;
1977   }
1978   inline void SetIsShaderResult(GLboolean result)
1979   {
1980     mIsShaderResult = result;
1981   }
1982   inline void SetIsTextureResult(GLboolean result)
1983   {
1984     mIsTextureResult = result;
1985   }
1986   inline void SetCheckFramebufferStatusResult(GLenum result)
1987   {
1988     mCheckFramebufferStatusResult = result;
1989   }
1990   inline void SetNumBinaryFormats(GLint numFormats)
1991   {
1992     mNumBinaryFormats = numFormats;
1993   }
1994   inline void SetBinaryFormats(GLint binaryFormats)
1995   {
1996     mBinaryFormats = binaryFormats;
1997   }
1998   inline void SetProgramBinaryLength(GLint length)
1999   {
2000     mProgramBinaryLength = length;
2001   }
2002
2003   inline bool GetVertexAttribArrayState(GLuint index)
2004   {
2005     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2006     {
2007       // out of range
2008       return false;
2009     }
2010     return mVertexAttribArrayState[index];
2011   }
2012   inline void ClearVertexAttribArrayChanged()
2013   {
2014     mVertexAttribArrayChanged = false;
2015   }
2016   inline bool GetVertexAttribArrayChanged()
2017   {
2018     return mVertexAttribArrayChanged;
2019   }
2020
2021   //Methods for CullFace verification
2022   inline void EnableCullFaceCallTrace(bool enable)
2023   {
2024     mCullFaceTrace.Enable(enable);
2025   }
2026   inline void ResetCullFaceCallStack()
2027   {
2028     mCullFaceTrace.Reset();
2029   }
2030   inline TraceCallStack& GetCullFaceTrace()
2031   {
2032     return mCullFaceTrace;
2033   }
2034
2035   //Methods for Enable/Disable call verification
2036   inline void EnableEnableDisableCallTrace(bool enable)
2037   {
2038     mEnableDisableTrace.Enable(enable);
2039   }
2040   inline void ResetEnableDisableCallStack()
2041   {
2042     mEnableDisableTrace.Reset();
2043   }
2044   inline TraceCallStack& GetEnableDisableTrace()
2045   {
2046     return mEnableDisableTrace;
2047   }
2048
2049   //Methods for Shader verification
2050   inline void EnableShaderCallTrace(bool enable)
2051   {
2052     mShaderTrace.Enable(enable);
2053   }
2054   inline void ResetShaderCallStack()
2055   {
2056     mShaderTrace.Reset();
2057   }
2058   inline TraceCallStack& GetShaderTrace()
2059   {
2060     return mShaderTrace;
2061   }
2062
2063   //Methods for Texture verification
2064   inline void EnableTextureCallTrace(bool enable)
2065   {
2066     mTextureTrace.Enable(enable);
2067   }
2068   inline void ResetTextureCallStack()
2069   {
2070     mTextureTrace.Reset();
2071   }
2072   inline TraceCallStack& GetTextureTrace()
2073   {
2074     return mTextureTrace;
2075   }
2076
2077   //Methods for Texture verification
2078   inline void EnableTexParameterCallTrace(bool enable)
2079   {
2080     mTexParamaterTrace.Enable(enable);
2081   }
2082   inline void ResetTexParameterCallStack()
2083   {
2084     mTexParamaterTrace.Reset();
2085   }
2086   inline TraceCallStack& GetTexParameterTrace()
2087   {
2088     return mTexParamaterTrace;
2089   }
2090
2091   //Methods for Draw verification
2092   inline void EnableDrawCallTrace(bool enable)
2093   {
2094     mDrawTrace.Enable(enable);
2095   }
2096   inline void ResetDrawCallStack()
2097   {
2098     mDrawTrace.Reset();
2099   }
2100   inline TraceCallStack& GetDrawTrace()
2101   {
2102     return mDrawTrace;
2103   }
2104
2105   //Methods for Depth function verification
2106   inline void EnableDepthFunctionCallTrace(bool enable)
2107   {
2108     mDepthFunctionTrace.Enable(enable);
2109   }
2110   inline void ResetDepthFunctionCallStack()
2111   {
2112     mDepthFunctionTrace.Reset();
2113   }
2114   inline TraceCallStack& GetDepthFunctionTrace()
2115   {
2116     return mDepthFunctionTrace;
2117   }
2118
2119   //Methods for Stencil function verification
2120   inline void EnableStencilFunctionCallTrace(bool enable)
2121   {
2122     mStencilFunctionTrace.Enable(enable);
2123   }
2124   inline void ResetStencilFunctionCallStack()
2125   {
2126     mStencilFunctionTrace.Reset();
2127   }
2128   inline TraceCallStack& GetStencilFunctionTrace()
2129   {
2130     return mStencilFunctionTrace;
2131   }
2132
2133   //Methods for Scissor verification
2134   inline void EnableScissorCallTrace(bool enable)
2135   {
2136     mScissorTrace.Enable(enable);
2137   }
2138   inline void ResetScissorCallStack()
2139   {
2140     mScissorTrace.Reset();
2141   }
2142   inline TraceCallStack& GetScissorTrace()
2143   {
2144     return mScissorTrace;
2145   }
2146
2147   //Methods for Uniform function verification
2148   inline void EnableSetUniformCallTrace(bool enable)
2149   {
2150     mSetUniformTrace.Enable(enable);
2151   }
2152   inline void ResetSetUniformCallStack()
2153   {
2154     mSetUniformTrace.Reset();
2155   }
2156   inline TraceCallStack& GetSetUniformTrace()
2157   {
2158     return mSetUniformTrace;
2159   }
2160
2161   //Methods for Viewport verification
2162   inline void EnableViewportCallTrace(bool enable)
2163   {
2164     mViewportTrace.Enable(enable);
2165   }
2166   inline void ResetViewportCallStack()
2167   {
2168     mViewportTrace.Reset();
2169   }
2170   inline TraceCallStack& GetViewportTrace()
2171   {
2172     return mViewportTrace;
2173   }
2174
2175   template<typename T>
2176   inline bool GetUniformValue(const char* name, T& value) const
2177   {
2178     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2179         program_it != mUniforms.end();
2180         ++program_it)
2181     {
2182       const UniformIDMap& uniformIDs = program_it->second;
2183
2184       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2185       if(uniform_it != uniformIDs.end())
2186       {
2187         // found one matching uniform name, lets check the value...
2188         GLuint programId = program_it->first;
2189         GLint  uniformId = uniform_it->second;
2190
2191         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2192         return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2193       }
2194     }
2195     return false;
2196   }
2197
2198   template<typename T>
2199   inline bool CheckUniformValue(const char* name, const T& value) const
2200   {
2201     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2202         program_it != mUniforms.end();
2203         ++program_it)
2204     {
2205       const UniformIDMap& uniformIDs = program_it->second;
2206
2207       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2208       if(uniform_it != uniformIDs.end())
2209       {
2210         // found one matching uniform name, lets check the value...
2211         GLuint programId = program_it->first;
2212         GLint  uniformId = uniform_it->second;
2213
2214         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2215         if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2216         {
2217           // the value matches
2218           return true;
2219         }
2220       }
2221     }
2222
2223     fprintf(stderr, "Not found, printing possible values:\n");
2224     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2225         program_it != mUniforms.end();
2226         ++program_it)
2227     {
2228       const UniformIDMap& uniformIDs = program_it->second;
2229
2230       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2231       if(uniform_it != uniformIDs.end())
2232       {
2233         // found one matching uniform name, lets check the value...
2234         GLuint programId = program_it->first;
2235         GLint  uniformId = uniform_it->second;
2236
2237         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2238         T                             origValue;
2239         if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2240         {
2241           std::stringstream out;
2242           out << uniform_it->first << ": " << origValue;
2243           fprintf(stderr, "%s\n", out.str().c_str());
2244         }
2245       }
2246     }
2247     return false;
2248   }
2249
2250   template<typename T>
2251   inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2252   {
2253     const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2254     return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2255   }
2256
2257   inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2258   {
2259     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2260         program_it != mUniforms.end();
2261         ++program_it)
2262     {
2263       const UniformIDMap& uniformIDs = program_it->second;
2264
2265       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2266       if(uniform_it != uniformIDs.end())
2267       {
2268         programId = program_it->first;
2269         uniformId = uniform_it->second;
2270         return true;
2271       }
2272     }
2273     return false;
2274   }
2275
2276   inline GLuint GetLastShaderCompiled() const
2277   {
2278     return mLastShaderCompiled;
2279   }
2280
2281   inline GLuint GetLastProgramCreated() const
2282   {
2283     return mLastProgramIdUsed;
2284   }
2285
2286   inline GLbitfield GetLastClearMask() const
2287   {
2288     return mLastClearBitMask;
2289   }
2290
2291   enum AttribType
2292   {
2293     ATTRIB_UNKNOWN = -1,
2294     ATTRIB_POSITION,
2295     ATTRIB_NORMAL,
2296     ATTRIB_TEXCOORD,
2297     ATTRIB_COLOR,
2298     ATTRIB_BONE_WEIGHTS,
2299     ATTRIB_BONE_INDICES,
2300     ATTRIB_TYPE_LAST
2301   };
2302
2303   struct ScissorParams
2304   {
2305     GLint   x;
2306     GLint   y;
2307     GLsizei width;
2308     GLsizei height;
2309
2310     ScissorParams()
2311     : x(0),
2312       y(0),
2313       width(0),
2314       height(0)
2315     {
2316     }
2317   };
2318
2319   // Methods to check scissor tests
2320   inline const ScissorParams& GetScissorParams() const
2321   {
2322     return mScissorParams;
2323   }
2324
2325   struct ColorMaskParams
2326   {
2327     GLboolean red;
2328     GLboolean green;
2329     GLboolean blue;
2330     GLboolean alpha;
2331
2332     ColorMaskParams()
2333     : red(true),
2334       green(true),
2335       blue(true),
2336       alpha(true)
2337     {
2338     }
2339   };
2340
2341   inline bool GetProgramBinaryCalled() const
2342   {
2343     return mGetProgramBinaryCalled;
2344   }
2345
2346   inline unsigned int GetClearCountCalled() const
2347   {
2348     return mClearCount;
2349   }
2350
2351   inline const ColorMaskParams& GetColorMaskParams() const
2352   {
2353     return mColorMaskParams;
2354   }
2355
2356   typedef std::vector<size_t>   BufferDataCalls;
2357   inline const BufferDataCalls& GetBufferDataCalls() const
2358   {
2359     return mBufferDataCalls;
2360   }
2361   inline void ResetBufferDataCalls()
2362   {
2363     mBufferDataCalls.clear();
2364   }
2365
2366   typedef std::vector<size_t>      BufferSubDataCalls;
2367   inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2368   {
2369     return mBufferSubDataCalls;
2370   }
2371   inline void ResetBufferSubDataCalls()
2372   {
2373     mBufferSubDataCalls.clear();
2374   }
2375
2376 private:
2377   GLuint                                mCurrentProgram;
2378   GLuint                                mCompileStatus;
2379   BufferDataCalls                       mBufferDataCalls;
2380   BufferSubDataCalls                    mBufferSubDataCalls;
2381   GLuint                                mLinkStatus;
2382   GLint                                 mNumberOfActiveUniforms;
2383   GLint                                 mGetAttribLocationResult;
2384   GLenum                                mGetErrorResult;
2385   GLubyte*                              mGetStringResult;
2386   GLboolean                             mIsBufferResult;
2387   GLboolean                             mIsEnabledResult;
2388   GLboolean                             mIsFramebufferResult;
2389   GLboolean                             mIsProgramResult;
2390   GLboolean                             mIsRenderbufferResult;
2391   GLboolean                             mIsShaderResult;
2392   GLboolean                             mIsTextureResult;
2393   GLenum                                mActiveTextureUnit;
2394   GLenum                                mCheckFramebufferStatusResult;
2395   GLint                                 mFramebufferStatus;
2396   GLenum                                mFramebufferDepthAttached;
2397   GLenum                                mFramebufferStencilAttached;
2398   GLuint                                mFramebufferColorAttachmentCount;
2399   GLuint                                mFrameBufferColorStatus;
2400   GLint                                 mNumBinaryFormats;
2401   GLint                                 mBinaryFormats;
2402   GLint                                 mProgramBinaryLength;
2403   bool                                  mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2404   bool                                  mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2405   bool                                  mGetProgramBinaryCalled;
2406   typedef std::map<GLuint, std::string> ShaderSourceMap;
2407   ShaderSourceMap                       mShaderSources;
2408   GLuint                                mLastShaderCompiled;
2409   GLbitfield                            mLastClearBitMask;
2410   Vector4                               mLastClearColor;
2411   unsigned int                          mClearCount;
2412
2413   Vector4 mLastBlendColor;
2414   GLenum  mLastBlendEquationRgb;
2415   GLenum  mLastBlendEquationAlpha;
2416   GLenum  mLastBlendFuncSrcRgb;
2417   GLenum  mLastBlendFuncDstRgb;
2418   GLenum  mLastBlendFuncSrcAlpha;
2419   GLenum  mLastBlendFuncDstAlpha;
2420
2421   GLboolean mLastDepthMask;
2422
2423   // Data for manipulating the IDs returned by GenTextures
2424   GLuint              mLastAutoTextureIdUsed;
2425   GLuint              mNumGeneratedTextures;
2426   std::vector<GLuint> mNextTextureIds;
2427   std::vector<GLuint> mDeletedTextureIds;
2428   std::vector<GLuint> mBoundTextures;
2429
2430   struct ActiveTextureType
2431   {
2432     std::vector<GLuint> mBoundTextures;
2433   };
2434
2435   ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2436
2437   TraceCallStack mCullFaceTrace;
2438   TraceCallStack mEnableDisableTrace;
2439   TraceCallStack mShaderTrace;
2440   TraceCallStack mTextureTrace{"GlA Texture:"};
2441   TraceCallStack mTexParamaterTrace;
2442   TraceCallStack mDrawTrace;
2443   TraceCallStack mDepthFunctionTrace;
2444   TraceCallStack mStencilFunctionTrace;
2445   TraceCallStack mScissorTrace;
2446   TraceCallStack mSetUniformTrace;
2447   TraceCallStack mViewportTrace;
2448
2449   // Shaders & Uniforms
2450   GLuint                                 mLastShaderIdUsed;
2451   GLuint                                 mLastProgramIdUsed;
2452   GLuint                                 mLastUniformIdUsed;
2453   typedef std::map<std::string, GLint>   UniformIDMap;
2454   typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2455   ProgramUniformMap                      mUniforms;
2456
2457   template<typename T>
2458   struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2459   {
2460   public:
2461     typedef std::map<GLint, T>                UniformValueMap;
2462     typedef std::map<GLuint, UniformValueMap> Map;
2463
2464     bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2465     {
2466       if(program == 0)
2467       {
2468         return false;
2469       }
2470
2471       typename Map::iterator it = Map::find(program);
2472       if(it == Map::end())
2473       {
2474         // if its the first uniform for this program add it
2475         std::pair<typename Map::iterator, bool> result =
2476           Map::insert(typename Map::value_type(program, UniformValueMap()));
2477         it = result.first;
2478       }
2479
2480       UniformValueMap& uniforms = it->second;
2481       uniforms[uniform]         = value;
2482
2483       return true;
2484     }
2485
2486     bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2487     {
2488       T uniformValue;
2489       if(GetUniformValue(program, uniform, uniformValue))
2490       {
2491         return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2492       }
2493
2494       return false;
2495     }
2496
2497     bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2498     {
2499       if(program == 0)
2500       {
2501         return false;
2502       }
2503
2504       typename Map::const_iterator it = Map::find(program);
2505       if(it == Map::end())
2506       {
2507         // Uniform values always initialised as 0
2508         value = GetZero();
2509         return true;
2510       }
2511
2512       const UniformValueMap&                   uniforms = it->second;
2513       typename UniformValueMap::const_iterator it2      = uniforms.find(uniform);
2514       if(it2 == uniforms.end())
2515       {
2516         // Uniform values always initialised as 0
2517         value = GetZero();
2518         return true;
2519       }
2520       value = it2->second;
2521
2522       return true;
2523     }
2524
2525     T GetZero() const;
2526   };
2527   ProgramUniformValue<int>     mProgramUniforms1i;
2528   ProgramUniformValue<float>   mProgramUniforms1f;
2529   ProgramUniformValue<Vector2> mProgramUniforms2f;
2530   ProgramUniformValue<Vector3> mProgramUniforms3f;
2531   ProgramUniformValue<Vector4> mProgramUniforms4f;
2532   ProgramUniformValue<Matrix>  mProgramUniformsMat4;
2533   ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2534
2535   inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2536   {
2537     return mProgramUniforms1i;
2538   }
2539   inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2540   {
2541     return mProgramUniforms1f;
2542   }
2543   inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2544   {
2545     return mProgramUniforms2f;
2546   }
2547   inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2548   {
2549     return mProgramUniforms3f;
2550   }
2551   inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2552   {
2553     return mProgramUniforms4f;
2554   }
2555   inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2556   {
2557     return mProgramUniformsMat4;
2558   }
2559   inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2560   {
2561     return mProgramUniformsMat3;
2562   }
2563   inline void SetVertexAttribArray(GLuint index, bool state)
2564   {
2565     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2566     {
2567       // out of range
2568       return;
2569     }
2570     mVertexAttribArrayState[index] = state;
2571     mVertexAttribArrayChanged      = true;
2572   }
2573
2574   ScissorParams   mScissorParams;
2575   ColorMaskParams mColorMaskParams;
2576 };
2577
2578 template<>
2579 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2580 {
2581   return 0;
2582 }
2583
2584 template<>
2585 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2586 {
2587   return 0.0f;
2588 }
2589
2590 template<>
2591 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2592 {
2593   return Vector2::ZERO;
2594 }
2595
2596 template<>
2597 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2598 {
2599   return Vector3::ZERO;
2600 }
2601
2602 template<>
2603 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2604 {
2605   return Vector4::ZERO;
2606 }
2607
2608 template<>
2609 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2610 {
2611   return Matrix();
2612 }
2613
2614 template<>
2615 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2616 {
2617   return Matrix3(Matrix());
2618 }
2619
2620 } // namespace Dali
2621
2622 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2623 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2624
2625 #endif // TEST_GL_ABSTRACTION_H