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