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