automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h

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