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