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