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