automated-tests/src/dali/dali-test-suite-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
 975     GetUniformLocation(program, "uRendererColor");
 976     GetUniformLocation(program, "uCustom");
 977     GetUniformLocation(program, "uCustom3");
 978     GetUniformLocation(program, "uFadeColor");
 979     GetUniformLocation(program, "uUniform1");
 980     GetUniformLocation(program, "uUniform2");
 981     GetUniformLocation(program, "uUniform3");
 982     GetUniformLocation(program, "uFadeProgress");
 983     GetUniformLocation(program, "uANormalMatrix");
 984     GetUniformLocation(program, "sEffect");
 985     GetUniformLocation(program, "sTexture");
 986     GetUniformLocation(program, "sTextureRect");
 987     GetUniformLocation(program, "sGloss");
 988     GetUniformLocation(program, "uColor");
 989     GetUniformLocation(program, "uModelMatrix");
 990     GetUniformLocation(program, "uModelView");
 991     GetUniformLocation(program, "uMvpMatrix");
 992     GetUniformLocation(program, "uNormalMatrix");
 993     GetUniformLocation(program, "uProjection");
 994     GetUniformLocation(program, "uSize");
 995     GetUniformLocation(program, "uViewMatrix");
 996     GetUniformLocation(program, "uLightCameraProjectionMatrix");
 997     GetUniformLocation(program, "uLightCameraViewMatrix");
 998   }
 999
1000   inline void PixelStorei(GLenum pname, GLint param) override
1001   {
1002   }
1003
1004   inline void PolygonOffset(GLfloat factor, GLfloat units) override
1005   {
1006   }
1007
1008   inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1009   {
1010   }
1011
1012   inline void ReleaseShaderCompiler(void) override
1013   {
1014   }
1015
1016   inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1017   {
1018   }
1019
1020   inline void SampleCoverage(GLclampf value, GLboolean invert) override
1021   {
1022   }
1023
1024   inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1025   {
1026     mScissorParams.x      = x;
1027     mScissorParams.y      = y;
1028     mScissorParams.width  = width;
1029     mScissorParams.height = height;
1030
1031     std::stringstream out;
1032     out << x << ", " << y << ", " << width << ", " << height;
1033     TraceCallStack::NamedParams namedParams;
1034     namedParams["x"] << x;
1035     namedParams["y"] << y;
1036     namedParams["width"] << width;
1037     namedParams["height"] << height;
1038     mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1039   }
1040
1041   inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1042   {
1043   }
1044
1045   inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1046   {
1047     std::string stringBuilder;
1048     for(int i = 0; i < count; ++i)
1049     {
1050       stringBuilder += string[i];
1051     }
1052     mShaderSources[shader] = stringBuilder;
1053     mLastShaderCompiled    = shader;
1054   }
1055
1056   inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1057   {
1058     const std::string shaderSource       = mShaderSources[shader];
1059     const int         shaderSourceLength = static_cast<int>(shaderSource.length());
1060     if(shaderSourceLength < bufsize)
1061     {
1062       strncpy(source, shaderSource.c_str(), shaderSourceLength);
1063       *length = shaderSourceLength;
1064     }
1065     else
1066     {
1067       *length = bufsize - 1;
1068       strncpy(source, shaderSource.c_str(), *length);
1069       source[*length] = 0x0;
1070     }
1071   }
1072
1073   inline std::string GetShaderSource(GLuint shader)
1074   {
1075     return mShaderSources[shader];
1076   }
1077
1078   inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1079   {
1080     std::stringstream out;
1081     out << func << ", " << ref << ", " << mask;
1082
1083     TraceCallStack::NamedParams namedParams;
1084     namedParams["func"] << std::hex << func;
1085     namedParams["ref"] << ref;
1086     namedParams["mask"] << mask;
1087
1088     mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1089   }
1090
1091   inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1092   {
1093     std::stringstream out;
1094     out << face << ", " << func << ", " << ref << ", " << mask;
1095
1096     TraceCallStack::NamedParams namedParams;
1097     namedParams["face"] << std::hex << face;
1098     namedParams["func"] << std::hex << func;
1099     namedParams["ref"] << ref;
1100     namedParams["mask"] << mask;
1101
1102     mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1103   }
1104
1105   inline void StencilMask(GLuint mask) override
1106   {
1107     std::stringstream out;
1108     out << mask;
1109
1110     TraceCallStack::NamedParams namedParams;
1111     namedParams["mask"] << mask;
1112
1113     mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1114   }
1115
1116   inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1117   {
1118     std::stringstream out;
1119     out << face << ", " << mask;
1120
1121     TraceCallStack::NamedParams namedParams;
1122     namedParams["face"] << std::hex << face;
1123     namedParams["mask"] << mask;
1124
1125     mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1126   }
1127
1128   inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1129   {
1130     std::stringstream out;
1131     out << fail << ", " << zfail << ", " << zpass;
1132
1133     TraceCallStack::NamedParams namedParams;
1134     namedParams["fail"] << std::hex << fail;
1135     namedParams["zfail"] << std::hex << zfail;
1136     namedParams["zpass"] << std::hex << zpass;
1137
1138     mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1139   }
1140
1141   inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1142   {
1143     std::stringstream out;
1144     out << face << ", " << fail << ", " << zfail << "," << zpass;
1145
1146     TraceCallStack::NamedParams namedParams;
1147     namedParams["face"] << std::hex << face;
1148     namedParams["fail"] << std::hex << fail;
1149     namedParams["zfail"] << std::hex << zfail;
1150     namedParams["zpass"] << std::hex << zpass;
1151
1152     mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1153   }
1154
1155   inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1156   {
1157     std::stringstream out;
1158     out << target << ", " << level << ", " << width << ", " << height;
1159
1160     TraceCallStack::NamedParams namedParams;
1161     namedParams["target"] << std::hex << target;
1162     namedParams["level"] << level;
1163     namedParams["internalformat"] << internalformat;
1164     namedParams["width"] << width;
1165     namedParams["height"] << height;
1166     namedParams["border"] << border;
1167     namedParams["format"] << std::hex << format;
1168     namedParams["type"] << std::hex << type;
1169
1170     mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1171   }
1172
1173   inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1174   {
1175     std::stringstream out;
1176     out << target << ", " << pname << ", " << param;
1177
1178     TraceCallStack::NamedParams namedParams;
1179     namedParams["target"] << std::hex << target;
1180     namedParams["pname"] << std::hex << pname;
1181     namedParams["param"] << param;
1182
1183     mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1184   }
1185
1186   inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1187   {
1188     std::stringstream out;
1189     out << target << ", " << pname << ", " << params[0];
1190
1191     TraceCallStack::NamedParams namedParams;
1192     namedParams["target"] << std::hex << target;
1193     namedParams["pname"] << std::hex << pname;
1194     namedParams["params[0]"] << params[0];
1195
1196     mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1197   }
1198
1199   inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1200   {
1201     std::stringstream out;
1202     out << std::hex << target << ", " << pname << ", " << param;
1203     std::string params = out.str();
1204
1205     TraceCallStack::NamedParams namedParams;
1206     namedParams["target"] << std::hex << target;
1207     namedParams["pname"] << std::hex << pname;
1208     namedParams["param"] << param;
1209     mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1210   }
1211
1212   inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1213   {
1214     std::stringstream out;
1215     out << target << ", " << pname << ", " << params[0];
1216     TraceCallStack::NamedParams namedParams;
1217     namedParams["target"] << std::hex << target;
1218     namedParams["pname"] << std::hex << pname;
1219     namedParams["params[0]"] << params[0];
1220     mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1221   }
1222
1223   inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1224   {
1225     std::stringstream out;
1226     out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1227
1228     TraceCallStack::NamedParams namedParams;
1229     namedParams["target"] << std::hex << target;
1230     namedParams["level"] << level;
1231     namedParams["xoffset"] << xoffset;
1232     namedParams["yoffset"] << yoffset;
1233     namedParams["width"] << width;
1234     namedParams["height"] << height;
1235     mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1236   }
1237
1238   inline void Uniform1f(GLint location, GLfloat value) override
1239   {
1240     std::string params = std::to_string(value);
1241     AddUniformCallToTraceStack(location, params);
1242
1243     if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1244     {
1245       mGetErrorResult = GL_INVALID_OPERATION;
1246     }
1247   }
1248
1249   inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1250   {
1251     std::string params;
1252     for(int i = 0; i < count; ++i)
1253     {
1254       params = params + std::to_string(v[i]) + ",";
1255     }
1256
1257     AddUniformCallToTraceStack(location, params);
1258
1259     for(int i = 0; i < count; ++i)
1260     {
1261       if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1262       {
1263         mGetErrorResult = GL_INVALID_OPERATION;
1264         break;
1265       }
1266     }
1267   }
1268
1269   inline void Uniform1i(GLint location, GLint x) override
1270   {
1271     std::string params = std::to_string(x);
1272
1273     AddUniformCallToTraceStack(location, params);
1274
1275     if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1276     {
1277       mGetErrorResult = GL_INVALID_OPERATION;
1278     }
1279   }
1280
1281   inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1282   {
1283     std::ostringstream out;
1284     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1285     AddUniformCallToTraceStack(location, out.str());
1286
1287     for(int i = 0; i < count; ++i)
1288     {
1289       if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1290                                              location,
1291                                              v[i]))
1292       {
1293         mGetErrorResult = GL_INVALID_OPERATION;
1294         break;
1295       }
1296     }
1297   }
1298
1299   inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1300   {
1301     std::string params = std::to_string(x) + "," + std::to_string(y);
1302     AddUniformCallToTraceStack(location, params);
1303
1304     if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1305                                            location,
1306                                            Vector2(x, y)))
1307     {
1308       mGetErrorResult = GL_INVALID_OPERATION;
1309     }
1310   }
1311
1312   inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1313   {
1314     std::ostringstream out;
1315     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1316     AddUniformCallToTraceStack(location, out.str());
1317
1318     for(int i = 0; i < count; ++i)
1319     {
1320       if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1321                                              location,
1322                                              Vector2(v[2 * i], v[2 * i + 1])))
1323       {
1324         mGetErrorResult = GL_INVALID_OPERATION;
1325         break;
1326       }
1327     }
1328   }
1329
1330   inline void Uniform2i(GLint location, GLint x, GLint y) override
1331   {
1332     std::string params = std::to_string(x) + "," + std::to_string(y);
1333     AddUniformCallToTraceStack(location, params);
1334   }
1335
1336   inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1337   {
1338     std::ostringstream out;
1339     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1340     AddUniformCallToTraceStack(location, out.str());
1341   }
1342
1343   inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1344   {
1345     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1346     AddUniformCallToTraceStack(location, params);
1347
1348     if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1349                                            location,
1350                                            Vector3(x, y, z)))
1351     {
1352       mGetErrorResult = GL_INVALID_OPERATION;
1353     }
1354   }
1355
1356   inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1357   {
1358     std::ostringstream out;
1359     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1360     AddUniformCallToTraceStack(location, out.str());
1361
1362     for(int i = 0; i < count; ++i)
1363     {
1364       if(!mProgramUniforms3f.SetUniformValue(
1365            mCurrentProgram,
1366            location,
1367            Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1368       {
1369         mGetErrorResult = GL_INVALID_OPERATION;
1370         break;
1371       }
1372     }
1373   }
1374
1375   inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1376   {
1377     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1378     AddUniformCallToTraceStack(location, params);
1379   }
1380
1381   inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1382   {
1383     std::ostringstream out;
1384     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1385     AddUniformCallToTraceStack(location, out.str());
1386   }
1387
1388   inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1389   {
1390     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1391     AddUniformCallToTraceStack(location, params);
1392
1393     if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1394                                            location,
1395                                            Vector4(x, y, z, w)))
1396     {
1397       mGetErrorResult = GL_INVALID_OPERATION;
1398     }
1399   }
1400
1401   inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1402   {
1403     std::ostringstream out;
1404     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1405     AddUniformCallToTraceStack(location, out.str());
1406
1407     for(int i = 0; i < count; ++i)
1408     {
1409       if(!mProgramUniforms4f.SetUniformValue(
1410            mCurrentProgram,
1411            location,
1412            Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1413       {
1414         mGetErrorResult = GL_INVALID_OPERATION;
1415         break;
1416       }
1417     }
1418   }
1419
1420   inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1421   {
1422     std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1423     AddUniformCallToTraceStack(location, params);
1424   }
1425
1426   inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1427   {
1428     std::ostringstream out;
1429     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1430     AddUniformCallToTraceStack(location, out.str());
1431   }
1432
1433   inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1434   {
1435     std::ostringstream out;
1436     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1437     AddUniformCallToTraceStack(location, out.str());
1438   }
1439
1440   inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1441   {
1442     std::ostringstream out;
1443     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1444     AddUniformCallToTraceStack(location, out.str());
1445
1446     for(int i = 0; i < count; ++i)
1447     {
1448       if(!mProgramUniformsMat3.SetUniformValue(
1449            mCurrentProgram,
1450            location,
1451            Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1452       {
1453         mGetErrorResult = GL_INVALID_OPERATION;
1454         break;
1455       }
1456     }
1457   }
1458
1459   inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1460   {
1461     std::ostringstream out;
1462     for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1463     AddUniformCallToTraceStack(location, out.str());
1464
1465     for(int i = 0; i < count; ++i)
1466     {
1467       if(!mProgramUniformsMat4.SetUniformValue(
1468            mCurrentProgram,
1469            location,
1470            Matrix(value)))
1471       {
1472         mGetErrorResult = GL_INVALID_OPERATION;
1473         break;
1474       }
1475     }
1476   }
1477
1478   inline void UseProgram(GLuint program) override
1479   {
1480     mCurrentProgram = program;
1481   }
1482
1483   inline void ValidateProgram(GLuint program) override
1484   {
1485   }
1486
1487   inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1488   {
1489   }
1490
1491   inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1492   {
1493   }
1494
1495   inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1496   {
1497   }
1498
1499   inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1500   {
1501   }
1502
1503   inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1504   {
1505   }
1506
1507   inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1508   {
1509   }
1510
1511   inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1512   {
1513   }
1514
1515   inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1516   {
1517   }
1518
1519   inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1520   {
1521     TraceCallStack::NamedParams namedParams;
1522     namedParams["index"] << index;
1523     namedParams["size"] << size;
1524     namedParams["type"] << std::hex << type;
1525     namedParams["normalized"] << (normalized ? "T" : "F");
1526     namedParams["stride"] << stride;
1527     namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1528
1529     mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1530   }
1531
1532   inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1533   {
1534     std::string commaString(", ");
1535     std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1536
1537     mViewportTrace.PushCall("Viewport", params);
1538   }
1539
1540   /* OpenGL ES 3.0 */
1541
1542   inline void ReadBuffer(GLenum mode) override
1543   {
1544   }
1545
1546   inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1547   {
1548   }
1549
1550   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
1551   {
1552   }
1553
1554   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
1555   {
1556   }
1557
1558   inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1559   {
1560   }
1561
1562   inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1563   {
1564   }
1565
1566   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
1567   {
1568   }
1569
1570   inline void GenQueries(GLsizei n, GLuint* ids) override
1571   {
1572   }
1573
1574   inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1575   {
1576   }
1577
1578   inline GLboolean IsQuery(GLuint id) override
1579   {
1580     return false;
1581   }
1582
1583   inline void BeginQuery(GLenum target, GLuint id) override
1584   {
1585   }
1586
1587   inline void EndQuery(GLenum target) override
1588   {
1589   }
1590
1591   inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1592   {
1593   }
1594
1595   inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1596   {
1597   }
1598
1599   inline GLboolean UnmapBuffer(GLenum target) override
1600   {
1601     if(mMappedBuffer)
1602     {
1603       free(mMappedBuffer);
1604       mMappedBuffer = nullptr;
1605     }
1606     return true; // false indicates corruption, nothing else.
1607   }
1608
1609   inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1610   {
1611   }
1612
1613   inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1614   {
1615   }
1616
1617   inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1618   {
1619   }
1620
1621   inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1622   {
1623   }
1624
1625   inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1626   {
1627   }
1628
1629   inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1630   {
1631   }
1632
1633   inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1634   {
1635   }
1636
1637   inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1638   {
1639   }
1640
1641   inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1642   {
1643   }
1644
1645   inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1646   {
1647   }
1648
1649   inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1650   {
1651   }
1652
1653   inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1654   {
1655     mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1656     return mMappedBuffer;
1657   }
1658
1659   inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1660   {
1661   }
1662
1663   inline void BindVertexArray(GLuint array) override
1664   {
1665   }
1666
1667   inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1668   {
1669   }
1670
1671   inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1672   {
1673   }
1674
1675   inline GLboolean IsVertexArray(GLuint array) override
1676   {
1677     return false;
1678   }
1679
1680   inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1681   {
1682   }
1683
1684   inline void BeginTransformFeedback(GLenum primitiveMode) override
1685   {
1686   }
1687
1688   inline void EndTransformFeedback(void) override
1689   {
1690   }
1691
1692   inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1693   {
1694   }
1695
1696   inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1697   {
1698   }
1699
1700   inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1701   {
1702   }
1703
1704   inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1705   {
1706   }
1707
1708   inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1709   {
1710   }
1711
1712   inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1713   {
1714   }
1715
1716   inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1717   {
1718   }
1719
1720   inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1721   {
1722   }
1723
1724   inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1725   {
1726   }
1727
1728   inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1729   {
1730   }
1731
1732   inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1733   {
1734   }
1735
1736   inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1737   {
1738   }
1739
1740   inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1741   {
1742     return -1;
1743   }
1744
1745   inline void Uniform1ui(GLint location, GLuint v0) override
1746   {
1747   }
1748
1749   inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1750   {
1751   }
1752
1753   inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1754   {
1755   }
1756
1757   inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1758   {
1759   }
1760
1761   inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1762   {
1763   }
1764
1765   inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1766   {
1767   }
1768
1769   inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1770   {
1771   }
1772
1773   inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1774   {
1775   }
1776
1777   inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1778   {
1779   }
1780
1781   inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1782   {
1783   }
1784
1785   inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1786   {
1787   }
1788
1789   inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1790   {
1791   }
1792
1793   inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1794   {
1795     return NULL;
1796   }
1797
1798   inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1799   {
1800   }
1801
1802   inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1803   {
1804   }
1805
1806   inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1807   {
1808   }
1809
1810   inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1811   {
1812     return GL_INVALID_INDEX;
1813   }
1814
1815   inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1816   {
1817   }
1818
1819   inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1820   {
1821   }
1822
1823   inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1824   {
1825   }
1826
1827   inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1828   {
1829   }
1830
1831   inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1832   {
1833   }
1834
1835   inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1836   {
1837     return NULL;
1838   }
1839
1840   inline GLboolean IsSync(GLsync sync) override
1841   {
1842     return false;
1843   }
1844
1845   inline void DeleteSync(GLsync sync) override
1846   {
1847   }
1848
1849   inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1850   {
1851     return 0;
1852   }
1853
1854   inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1855   {
1856   }
1857
1858   inline void GetInteger64v(GLenum pname, GLint64* params) override
1859   {
1860   }
1861
1862   inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1863   {
1864   }
1865
1866   inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1867   {
1868   }
1869
1870   inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1871   {
1872   }
1873
1874   inline void GenSamplers(GLsizei count, GLuint* samplers) override
1875   {
1876   }
1877
1878   inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1879   {
1880   }
1881
1882   inline GLboolean IsSampler(GLuint sampler) override
1883   {
1884     return false;
1885   }
1886
1887   inline void BindSampler(GLuint unit, GLuint sampler) override
1888   {
1889   }
1890
1891   inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1892   {
1893   }
1894
1895   inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1896   {
1897   }
1898
1899   inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1900   {
1901   }
1902
1903   inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1904   {
1905   }
1906
1907   inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1908   {
1909   }
1910
1911   inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1912   {
1913   }
1914
1915   inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1916   {
1917   }
1918
1919   inline void BindTransformFeedback(GLenum target, GLuint id) override
1920   {
1921   }
1922
1923   inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1924   {
1925   }
1926
1927   inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1928   {
1929   }
1930
1931   inline GLboolean IsTransformFeedback(GLuint id) override
1932   {
1933     return false;
1934   }
1935
1936   inline void PauseTransformFeedback(void) override
1937   {
1938   }
1939
1940   inline void ResumeTransformFeedback(void) override
1941   {
1942   }
1943
1944   inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1945   {
1946     mGetProgramBinaryCalled = true;
1947   }
1948
1949   inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1950   {
1951   }
1952
1953   inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1954   {
1955   }
1956
1957   inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1958   {
1959   }
1960
1961   inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1962   {
1963   }
1964
1965   inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1966   {
1967   }
1968
1969   inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1970   {
1971   }
1972
1973   inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1974   {
1975   }
1976
1977   inline void BlendBarrier(void)
1978   {
1979   }
1980
1981 private:
1982   inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1983   {
1984     std::string name    = "<not found>";
1985     bool        matched = false;
1986
1987     UniformIDMap& map = mUniforms[mCurrentProgram];
1988     for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1989     {
1990       if(it->second == location)
1991       {
1992         name    = it->first;
1993         matched = true;
1994         break;
1995       }
1996     }
1997
1998     if(matched)
1999     {
2000       mSetUniformTrace.PushCall(name, value);
2001     }
2002   }
2003
2004 public: // TEST FUNCTIONS
2005   inline void SetCompileStatus(GLuint value)
2006   {
2007     mCompileStatus = value;
2008   }
2009   inline void SetLinkStatus(GLuint value)
2010   {
2011     mLinkStatus = value;
2012   }
2013   inline void SetAttribLocations(std::vector<std::string> locs)
2014   {
2015     mAttribLocs = locs;
2016   }
2017   inline void SetGetErrorResult(GLenum result)
2018   {
2019     mGetErrorResult = result;
2020   }
2021   inline void SetGetStringResult(GLubyte* result)
2022   {
2023     mGetStringResult = result;
2024   }
2025   inline void SetIsBufferResult(GLboolean result)
2026   {
2027     mIsBufferResult = result;
2028   }
2029   inline void SetIsEnabledResult(GLboolean result)
2030   {
2031     mIsEnabledResult = result;
2032   }
2033   inline void SetIsFramebufferResult(GLboolean result)
2034   {
2035     mIsFramebufferResult = result;
2036   }
2037   inline void SetIsProgramResult(GLboolean result)
2038   {
2039     mIsProgramResult = result;
2040   }
2041   inline void SetIsRenderbufferResult(GLboolean result)
2042   {
2043     mIsRenderbufferResult = result;
2044   }
2045   inline void SetIsShaderResult(GLboolean result)
2046   {
2047     mIsShaderResult = result;
2048   }
2049   inline void SetIsTextureResult(GLboolean result)
2050   {
2051     mIsTextureResult = result;
2052   }
2053   inline void SetCheckFramebufferStatusResult(GLenum result)
2054   {
2055     mCheckFramebufferStatusResult = result;
2056   }
2057   inline void SetNumBinaryFormats(GLint numFormats)
2058   {
2059     mNumBinaryFormats = numFormats;
2060   }
2061   inline void SetBinaryFormats(GLint binaryFormats)
2062   {
2063     mBinaryFormats = binaryFormats;
2064   }
2065   inline void SetProgramBinaryLength(GLint length)
2066   {
2067     mProgramBinaryLength = length;
2068   }
2069
2070   inline bool GetVertexAttribArrayState(GLuint index)
2071   {
2072     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2073     {
2074       // out of range
2075       return false;
2076     }
2077     return mVertexAttribArrayState[index];
2078   }
2079   inline void ClearVertexAttribArrayChanged()
2080   {
2081     mVertexAttribArrayChanged = false;
2082   }
2083   inline bool GetVertexAttribArrayChanged()
2084   {
2085     return mVertexAttribArrayChanged;
2086   }
2087
2088   //Methods for CullFace verification
2089   inline void EnableCullFaceCallTrace(bool enable)
2090   {
2091     mCullFaceTrace.Enable(enable);
2092   }
2093   inline void ResetCullFaceCallStack()
2094   {
2095     mCullFaceTrace.Reset();
2096   }
2097   inline TraceCallStack& GetCullFaceTrace()
2098   {
2099     return mCullFaceTrace;
2100   }
2101
2102   //Methods for Enable/Disable call verification
2103   inline void EnableEnableDisableCallTrace(bool enable)
2104   {
2105     mEnableDisableTrace.Enable(enable);
2106   }
2107   inline void ResetEnableDisableCallStack()
2108   {
2109     mEnableDisableTrace.Reset();
2110   }
2111   inline TraceCallStack& GetEnableDisableTrace()
2112   {
2113     return mEnableDisableTrace;
2114   }
2115
2116   //Methods for Shader verification
2117   inline void EnableShaderCallTrace(bool enable)
2118   {
2119     mShaderTrace.Enable(enable);
2120   }
2121   inline void ResetShaderCallStack()
2122   {
2123     mShaderTrace.Reset();
2124   }
2125   inline TraceCallStack& GetShaderTrace()
2126   {
2127     return mShaderTrace;
2128   }
2129
2130   //Methods for Texture verification
2131   inline void EnableTextureCallTrace(bool enable)
2132   {
2133     mTextureTrace.Enable(enable);
2134   }
2135   inline void ResetTextureCallStack()
2136   {
2137     mTextureTrace.Reset();
2138   }
2139   inline TraceCallStack& GetTextureTrace()
2140   {
2141     return mTextureTrace;
2142   }
2143
2144   //Methods for Texture verification
2145   inline void EnableTexParameterCallTrace(bool enable)
2146   {
2147     mTexParameterTrace.Enable(enable);
2148   }
2149   inline void ResetTexParameterCallStack()
2150   {
2151     mTexParameterTrace.Reset();
2152   }
2153   inline TraceCallStack& GetTexParameterTrace()
2154   {
2155     return mTexParameterTrace;
2156   }
2157
2158   //Methods for Draw verification
2159   inline void EnableDrawCallTrace(bool enable)
2160   {
2161     mDrawTrace.Enable(enable);
2162   }
2163   inline void ResetDrawCallStack()
2164   {
2165     mDrawTrace.Reset();
2166   }
2167   inline TraceCallStack& GetDrawTrace()
2168   {
2169     return mDrawTrace;
2170   }
2171
2172   //Methods for Depth function verification
2173   inline void EnableDepthFunctionCallTrace(bool enable)
2174   {
2175     mDepthFunctionTrace.Enable(enable);
2176   }
2177   inline void ResetDepthFunctionCallStack()
2178   {
2179     mDepthFunctionTrace.Reset();
2180   }
2181   inline TraceCallStack& GetDepthFunctionTrace()
2182   {
2183     return mDepthFunctionTrace;
2184   }
2185
2186   //Methods for Stencil function verification
2187   inline void EnableStencilFunctionCallTrace(bool enable)
2188   {
2189     mStencilFunctionTrace.Enable(enable);
2190   }
2191   inline void ResetStencilFunctionCallStack()
2192   {
2193     mStencilFunctionTrace.Reset();
2194   }
2195   inline TraceCallStack& GetStencilFunctionTrace()
2196   {
2197     return mStencilFunctionTrace;
2198   }
2199
2200   //Methods for Scissor verification
2201   inline void EnableScissorCallTrace(bool enable)
2202   {
2203     mScissorTrace.Enable(enable);
2204   }
2205   inline void ResetScissorCallStack()
2206   {
2207     mScissorTrace.Reset();
2208   }
2209   inline TraceCallStack& GetScissorTrace()
2210   {
2211     return mScissorTrace;
2212   }
2213
2214   //Methods for Uniform function verification
2215   inline void EnableSetUniformCallTrace(bool enable)
2216   {
2217     mSetUniformTrace.Enable(enable);
2218   }
2219   inline void ResetSetUniformCallStack()
2220   {
2221     mSetUniformTrace.Reset();
2222   }
2223   inline TraceCallStack& GetSetUniformTrace()
2224   {
2225     return mSetUniformTrace;
2226   }
2227
2228   //Methods for Viewport verification
2229   inline void EnableViewportCallTrace(bool enable)
2230   {
2231     mViewportTrace.Enable(enable);
2232   }
2233   inline void ResetViewportCallStack()
2234   {
2235     mViewportTrace.Reset();
2236   }
2237   inline TraceCallStack& GetViewportTrace()
2238   {
2239     return mViewportTrace;
2240   }
2241   inline TraceCallStack& GetBufferTrace()
2242   {
2243     return mBufferTrace;
2244   }
2245
2246   template<typename T>
2247   inline bool GetUniformValue(const char* name, T& value) const
2248   {
2249     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2250         program_it != mUniforms.end();
2251         ++program_it)
2252     {
2253       const UniformIDMap& uniformIDs = program_it->second;
2254
2255       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2256       if(uniform_it != uniformIDs.end())
2257       {
2258         // found one matching uniform name, lets check the value...
2259         GLuint programId = program_it->first;
2260         GLint  uniformId = uniform_it->second;
2261
2262         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2263         return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2264       }
2265     }
2266     return false;
2267   }
2268
2269   template<typename T>
2270   inline bool CheckUniformValue(const char* name, const T& value) const
2271   {
2272     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2273         program_it != mUniforms.end();
2274         ++program_it)
2275     {
2276       const UniformIDMap& uniformIDs = program_it->second;
2277
2278       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2279       if(uniform_it != uniformIDs.end())
2280       {
2281         // found one matching uniform name, lets check the value...
2282         GLuint programId = program_it->first;
2283         GLint  uniformId = uniform_it->second;
2284
2285         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2286         if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2287         {
2288           // the value matches
2289           return true;
2290         }
2291       }
2292     }
2293
2294     fprintf(stderr, "Not found, printing possible values:\n");
2295     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2296         program_it != mUniforms.end();
2297         ++program_it)
2298     {
2299       const UniformIDMap& uniformIDs = program_it->second;
2300
2301       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2302       if(uniform_it != uniformIDs.end())
2303       {
2304         // found one matching uniform name, lets check the value...
2305         GLuint programId = program_it->first;
2306         GLint  uniformId = uniform_it->second;
2307
2308         const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2309         T                             origValue;
2310         if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2311         {
2312           std::stringstream out;
2313           out << uniform_it->first << ": " << origValue;
2314           fprintf(stderr, "%s\n", out.str().c_str());
2315         }
2316       }
2317     }
2318     return false;
2319   }
2320
2321   template<typename T>
2322   inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2323   {
2324     const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2325     return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2326   }
2327
2328   inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2329   {
2330     for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2331         program_it != mUniforms.end();
2332         ++program_it)
2333     {
2334       const UniformIDMap& uniformIDs = program_it->second;
2335
2336       UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2337       if(uniform_it != uniformIDs.end())
2338       {
2339         programId = program_it->first;
2340         uniformId = uniform_it->second;
2341         return true;
2342       }
2343     }
2344     return false;
2345   }
2346
2347   inline GLuint GetLastShaderCompiled() const
2348   {
2349     return mLastShaderCompiled;
2350   }
2351
2352   inline GLuint GetLastProgramCreated() const
2353   {
2354     return mLastProgramIdUsed;
2355   }
2356
2357   inline GLbitfield GetLastClearMask() const
2358   {
2359     return mLastClearBitMask;
2360   }
2361
2362   enum AttribType
2363   {
2364     ATTRIB_UNKNOWN = -1,
2365     ATTRIB_POSITION,
2366     ATTRIB_NORMAL,
2367     ATTRIB_TEXCOORD,
2368     ATTRIB_COLOR,
2369     ATTRIB_BONE_WEIGHTS,
2370     ATTRIB_BONE_INDICES,
2371     ATTRIB_TYPE_LAST
2372   };
2373
2374   struct ScissorParams
2375   {
2376     GLint   x;
2377     GLint   y;
2378     GLsizei width;
2379     GLsizei height;
2380
2381     ScissorParams()
2382     : x(0),
2383       y(0),
2384       width(0),
2385       height(0)
2386     {
2387     }
2388   };
2389
2390   // Methods to check scissor tests
2391   inline const ScissorParams& GetScissorParams() const
2392   {
2393     return mScissorParams;
2394   }
2395
2396   struct ColorMaskParams
2397   {
2398     GLboolean red;
2399     GLboolean green;
2400     GLboolean blue;
2401     GLboolean alpha;
2402
2403     ColorMaskParams()
2404     : red(true),
2405       green(true),
2406       blue(true),
2407       alpha(true)
2408     {
2409     }
2410   };
2411
2412   inline bool GetProgramBinaryCalled() const
2413   {
2414     return mGetProgramBinaryCalled;
2415   }
2416
2417   inline unsigned int GetClearCountCalled() const
2418   {
2419     return mClearCount;
2420   }
2421
2422   inline const ColorMaskParams& GetColorMaskParams() const
2423   {
2424     return mColorMaskParams;
2425   }
2426
2427   typedef std::vector<size_t>   BufferDataCalls;
2428   inline const BufferDataCalls& GetBufferDataCalls() const
2429   {
2430     return mBufferDataCalls;
2431   }
2432   inline void ResetBufferDataCalls()
2433   {
2434     mBufferDataCalls.clear();
2435   }
2436
2437   typedef std::vector<size_t>      BufferSubDataCalls;
2438   inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2439   {
2440     return mBufferSubDataCalls;
2441   }
2442   inline void ResetBufferSubDataCalls()
2443   {
2444     mBufferSubDataCalls.clear();
2445   }
2446
2447 private:
2448   GLuint                                mCurrentProgram;
2449   GLuint                                mCompileStatus;
2450   BufferDataCalls                       mBufferDataCalls;
2451   BufferSubDataCalls                    mBufferSubDataCalls;
2452   GLvoid*                               mMappedBuffer{nullptr};
2453   GLuint                                mLinkStatus;
2454   GLint                                 mNumberOfActiveUniforms;
2455   GLenum                                mGetErrorResult;
2456   GLubyte*                              mGetStringResult;
2457   GLboolean                             mIsBufferResult;
2458   GLboolean                             mIsEnabledResult;
2459   GLboolean                             mIsFramebufferResult;
2460   GLboolean                             mIsProgramResult;
2461   GLboolean                             mIsRenderbufferResult;
2462   GLboolean                             mIsShaderResult;
2463   GLboolean                             mIsTextureResult;
2464   GLenum                                mActiveTextureUnit;
2465   GLenum                                mCheckFramebufferStatusResult;
2466   GLint                                 mFramebufferStatus;
2467   GLenum                                mFramebufferDepthAttached;
2468   GLenum                                mFramebufferStencilAttached;
2469   GLuint                                mFramebufferColorAttachmentCount;
2470   GLuint                                mFrameBufferColorStatus;
2471   GLint                                 mNumBinaryFormats;
2472   GLint                                 mBinaryFormats;
2473   GLint                                 mProgramBinaryLength;
2474   bool                                  mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2475   bool                                  mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2476   bool                                  mGetProgramBinaryCalled;
2477   typedef std::map<GLuint, std::string> ShaderSourceMap;
2478   ShaderSourceMap                       mShaderSources;
2479   std::vector<std::string>              mAttribLocs; // should be bound to shader
2480   GLuint                                mLastShaderCompiled;
2481   GLbitfield                            mLastClearBitMask;
2482   Vector4                               mLastClearColor;
2483   unsigned int                          mClearCount;
2484
2485   Vector4 mLastBlendColor;
2486   GLenum  mLastBlendEquationRgb;
2487   GLenum  mLastBlendEquationAlpha;
2488   GLenum  mLastBlendFuncSrcRgb;
2489   GLenum  mLastBlendFuncDstRgb;
2490   GLenum  mLastBlendFuncSrcAlpha;
2491   GLenum  mLastBlendFuncDstAlpha;
2492
2493   GLboolean mLastDepthMask;
2494
2495   // Data for manipulating the IDs returned by GenTextures
2496   GLuint              mLastAutoTextureIdUsed;
2497   GLuint              mNumGeneratedTextures;
2498   std::vector<GLuint> mNextTextureIds;
2499   std::vector<GLuint> mDeletedTextureIds;
2500   std::vector<GLuint> mBoundTextures;
2501
2502   struct ActiveTextureType
2503   {
2504     std::vector<GLuint> mBoundTextures;
2505   };
2506
2507   ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2508
2509   TraceCallStack mBufferTrace;
2510   TraceCallStack mCullFaceTrace;
2511   TraceCallStack mEnableDisableTrace;
2512   TraceCallStack mShaderTrace;
2513   TraceCallStack mTextureTrace;
2514   TraceCallStack mTexParameterTrace;
2515   TraceCallStack mDrawTrace;
2516   TraceCallStack mDepthFunctionTrace;
2517   TraceCallStack mStencilFunctionTrace;
2518   TraceCallStack mScissorTrace;
2519   TraceCallStack mSetUniformTrace;
2520   TraceCallStack mViewportTrace;
2521
2522   // Shaders & Uniforms
2523   GLuint                                 mLastShaderIdUsed;
2524   GLuint                                 mLastProgramIdUsed{0u};
2525   GLuint                                 mLastUniformIdUsed;
2526   typedef std::map<std::string, GLint>   UniformIDMap;
2527   typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2528   ProgramUniformMap                      mUniforms;
2529
2530   template<typename T>
2531   struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2532   {
2533   public:
2534     typedef std::map<GLint, T>                UniformValueMap;
2535     typedef std::map<GLuint, UniformValueMap> Map;
2536
2537     bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2538     {
2539       if(program == 0)
2540       {
2541         return false;
2542       }
2543
2544       typename Map::iterator it = Map::find(program);
2545       if(it == Map::end())
2546       {
2547         // if its the first uniform for this program add it
2548         std::pair<typename Map::iterator, bool> result =
2549           Map::insert(typename Map::value_type(program, UniformValueMap()));
2550         it = result.first;
2551       }
2552
2553       UniformValueMap& uniforms = it->second;
2554       uniforms[uniform]         = value;
2555
2556       return true;
2557     }
2558
2559     bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2560     {
2561       T uniformValue;
2562       if(GetUniformValue(program, uniform, uniformValue))
2563       {
2564         return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2565       }
2566
2567       return false;
2568     }
2569
2570     bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2571     {
2572       if(program == 0)
2573       {
2574         return false;
2575       }
2576
2577       typename Map::const_iterator it = Map::find(program);
2578       if(it == Map::end())
2579       {
2580         // Uniform values always initialised as 0
2581         value = GetZero();
2582         return true;
2583       }
2584
2585       const UniformValueMap&                   uniforms = it->second;
2586       typename UniformValueMap::const_iterator it2      = uniforms.find(uniform);
2587       if(it2 == uniforms.end())
2588       {
2589         // Uniform values always initialised as 0
2590         value = GetZero();
2591         return true;
2592       }
2593       value = it2->second;
2594
2595       return true;
2596     }
2597
2598     T GetZero() const;
2599   };
2600   ProgramUniformValue<int>     mProgramUniforms1i;
2601   ProgramUniformValue<float>   mProgramUniforms1f;
2602   ProgramUniformValue<Vector2> mProgramUniforms2f;
2603   ProgramUniformValue<Vector3> mProgramUniforms3f;
2604   ProgramUniformValue<Vector4> mProgramUniforms4f;
2605   ProgramUniformValue<Matrix>  mProgramUniformsMat4;
2606   ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2607
2608   inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2609   {
2610     return mProgramUniforms1i;
2611   }
2612   inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2613   {
2614     return mProgramUniforms1f;
2615   }
2616   inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2617   {
2618     return mProgramUniforms2f;
2619   }
2620   inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2621   {
2622     return mProgramUniforms3f;
2623   }
2624   inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2625   {
2626     return mProgramUniforms4f;
2627   }
2628   inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2629   {
2630     return mProgramUniformsMat4;
2631   }
2632   inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2633   {
2634     return mProgramUniformsMat3;
2635   }
2636   inline void SetVertexAttribArray(GLuint index, bool state)
2637   {
2638     if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2639     {
2640       // out of range
2641       return;
2642     }
2643     mVertexAttribArrayState[index] = state;
2644     mVertexAttribArrayChanged      = true;
2645   }
2646
2647   ScissorParams   mScissorParams;
2648   ColorMaskParams mColorMaskParams;
2649 };
2650
2651 template<>
2652 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2653 {
2654   return 0;
2655 }
2656
2657 template<>
2658 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2659 {
2660   return 0.0f;
2661 }
2662
2663 template<>
2664 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2665 {
2666   return Vector2::ZERO;
2667 }
2668
2669 template<>
2670 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2671 {
2672   return Vector3::ZERO;
2673 }
2674
2675 template<>
2676 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2677 {
2678   return Vector4::ZERO;
2679 }
2680
2681 template<>
2682 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2683 {
2684   return Matrix();
2685 }
2686
2687 template<>
2688 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2689 {
2690   return Matrix3(Matrix());
2691 }
2692
2693 } // namespace Dali
2694
2695 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2696 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2697
2698 #endif // TEST_GL_ABSTRACTION_H