1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2023 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <cstring> // for strcmp
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>
45 UniformData(const std::string& name, Property::Type type = Property::Type::NONE)
55 GLenum type{GL_FLOAT};
60 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
63 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
66 ~TestGlAbstraction() override;
69 void PreRender() override;
70 void PostRender() override;
72 bool IsSurfacelessContextSupported() const override;
74 bool IsAdvancedBlendEquationSupported() override;
76 bool IsMultisampledRenderToTextureSupported() override;
78 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
80 std::string GetShaderVersionPrefix();
82 std::string GetVertexShaderPrefix();
84 std::string GetFragmentShaderPrefix();
86 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
90 inline void ActiveTexture(GLenum textureUnit) override
92 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
95 inline GLenum GetActiveTextureUnit() const
97 return mActiveTextureUnit + GL_TEXTURE0;
100 inline void AttachShader(GLuint program, GLuint shader) override
102 std::stringstream out;
103 out << program << ", " << shader;
105 TraceCallStack::NamedParams namedParams;
106 namedParams["program"] << program;
107 namedParams["shader"] << shader;
108 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
111 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
115 inline void BindBuffer(GLenum target, GLuint buffer) override
117 std::ostringstream o;
118 o << std::hex << target << ", " << buffer;
119 TraceCallStack::NamedParams namedParams;
120 namedParams["target"] << target;
121 namedParams["buffer"] << buffer;
122 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
125 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
128 mFramebufferStatus |= 2;
131 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
136 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
137 * @return A vector containing the IDs that were bound.
139 inline const std::vector<GLuint>& GetBoundTextures() const
141 return mBoundTextures;
145 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
146 * @param[in] activeTextureUnit The specific active texture unit.
147 * @return A vector containing the IDs that were bound.
149 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
151 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
155 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
157 inline void ClearBoundTextures()
159 mBoundTextures.clear();
161 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
163 mActiveTextures[i].mBoundTextures.clear();
167 inline void BindTexture(GLenum target, GLuint texture) override
169 // Record the bound textures for future checks
172 mBoundTextures.push_back(texture);
174 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
176 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
180 std::stringstream out;
181 out << std::hex << target << ", " << std::dec << texture;
183 TraceCallStack::NamedParams namedParams;
184 namedParams["target"] << std::hex << target;
185 namedParams["texture"] << texture;
187 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
190 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
192 mLastBlendColor.r = red;
193 mLastBlendColor.g = green;
194 mLastBlendColor.b = blue;
195 mLastBlendColor.a = alpha;
198 inline const Vector4& GetLastBlendColor() const
200 return mLastBlendColor;
203 inline void BlendEquation(GLenum mode) override
205 mLastBlendEquationRgb = mode;
206 mLastBlendEquationAlpha = mode;
209 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
211 mLastBlendEquationRgb = modeRgb;
212 mLastBlendEquationAlpha = modeAlpha;
215 inline GLenum GetLastBlendEquationRgb() const
217 return mLastBlendEquationRgb;
220 inline GLenum GetLastBlendEquationAlpha() const
222 return mLastBlendEquationAlpha;
225 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
227 mLastBlendFuncSrcRgb = sfactor;
228 mLastBlendFuncDstRgb = dfactor;
229 mLastBlendFuncSrcAlpha = sfactor;
230 mLastBlendFuncDstAlpha = dfactor;
233 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
235 mLastBlendFuncSrcRgb = srcRGB;
236 mLastBlendFuncDstRgb = dstRGB;
237 mLastBlendFuncSrcAlpha = srcAlpha;
238 mLastBlendFuncDstAlpha = dstAlpha;
241 inline GLenum GetLastBlendFuncSrcRgb() const
243 return mLastBlendFuncSrcRgb;
246 inline GLenum GetLastBlendFuncDstRgb() const
248 return mLastBlendFuncDstRgb;
251 inline GLenum GetLastBlendFuncSrcAlpha() const
253 return mLastBlendFuncSrcAlpha;
256 inline GLenum GetLastBlendFuncDstAlpha() const
258 return mLastBlendFuncDstAlpha;
261 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
263 std::ostringstream o;
264 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
265 TraceCallStack::NamedParams namedParams;
266 namedParams["target"] << std::hex << target;
267 namedParams["size"] << size;
268 namedParams["usage"] << usage;
270 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
272 mBufferDataCalls.push_back(size);
275 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
277 std::ostringstream o;
278 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
279 TraceCallStack::NamedParams namedParams;
280 namedParams["target"] << std::hex << target;
281 namedParams["offset"] << offset;
282 namedParams["size"] << size;
283 mBufferTrace.PushCall("BufferSubData", o.str());
285 mBufferSubDataCalls.push_back(size);
288 inline GLenum CheckFramebufferStatus(GLenum target) override
290 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
291 //Framebuffer texture have been called
292 if(mFramebufferStatus == 7)
294 return GL_FRAMEBUFFER_COMPLETE;
297 return mCheckFramebufferStatusResult;
300 inline GLuint CheckFramebufferColorAttachmentCount()
302 return mFramebufferColorAttachmentCount;
305 inline GLuint CheckFramebufferDepthAttachmentCount()
307 return mFramebufferDepthAttachmentCount;
310 inline GLuint CheckFramebufferStencilAttachmentCount()
312 return mFramebufferStencilAttachmentCount;
315 inline GLuint CheckFramebufferDepthStencilAttachmentCount()
317 return mFramebufferDepthStencilAttachmentCount;
320 inline GLenum CheckFramebufferDepthAttachment()
322 return mFramebufferDepthAttached;
325 inline GLenum CheckFramebufferStencilAttachment()
327 return mFramebufferStencilAttached;
330 inline GLenum CheckFramebufferDepthStencilAttachment()
332 return mFramebufferDepthStencilAttached;
335 inline void Clear(GLbitfield mask) override
338 mLastClearBitMask = mask;
341 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
343 mLastClearColor.r = red;
344 mLastClearColor.g = green;
345 mLastClearColor.b = blue;
346 mLastClearColor.a = alpha;
349 inline const Vector4& GetLastClearColor() const
351 return mLastClearColor;
354 inline void ClearDepthf(GLclampf depth) override
358 inline void ClearStencil(GLint s) override
360 std::stringstream out;
363 TraceCallStack::NamedParams namedParams;
364 namedParams["s"] << s;
366 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
369 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
371 mColorMaskParams.red = red;
372 mColorMaskParams.green = green;
373 mColorMaskParams.blue = blue;
374 mColorMaskParams.alpha = alpha;
377 inline void CompileShader(GLuint shader) override
379 std::stringstream out;
381 TraceCallStack::NamedParams namedParams;
382 namedParams["shader"] << shader;
384 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
387 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
389 std::stringstream out;
390 out << target << ", " << level << ", " << width << ", " << height;
392 TraceCallStack::NamedParams namedParams;
393 namedParams["target"] << std::hex << target;
394 namedParams["level"] << level;
395 namedParams["internalformat"] << internalformat;
396 namedParams["width"] << width;
397 namedParams["height"] << height;
398 namedParams["border"] << border;
399 namedParams["size"] << imageSize;
401 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
404 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
406 std::stringstream out;
407 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
409 TraceCallStack::NamedParams namedParams;
410 namedParams["target"] << std::hex << target;
411 namedParams["level"] << level;
412 namedParams["xoffset"] << xoffset;
413 namedParams["yoffset"] << yoffset;
414 namedParams["width"] << width;
415 namedParams["height"] << height;
416 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
419 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
423 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
427 inline GLuint CreateProgram(void) override
429 mShaderTrace.PushCall("CreateProgram", "");
431 ++mLastProgramIdUsed;
432 mUniforms[mLastProgramIdUsed] = UniformIDMap();
433 return mLastProgramIdUsed;
436 inline GLuint CreateShader(GLenum type) override
438 std::stringstream out;
441 TraceCallStack::NamedParams namedParams;
442 namedParams["type"] << std::hex << type;
443 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
445 return ++mLastShaderIdUsed;
448 inline void CullFace(GLenum mode) override
450 std::stringstream out;
451 out << std::hex << mode;
453 TraceCallStack::NamedParams namedParams;
454 namedParams["mode"] << std::hex << mode;
456 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
459 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
461 TraceCallStack::NamedParams namedParams;
462 namedParams["n"] << n;
463 namedParams["id"] << buffers[0];
464 mBufferTrace.PushCall("DeleteBuffers", namedParams.str(), namedParams);
467 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
471 inline void DeleteProgram(GLuint program) override
473 std::stringstream out;
476 TraceCallStack::NamedParams namedParams;
477 namedParams["program"] << program;
479 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
482 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
486 inline void DeleteShader(GLuint shader) override
488 std::stringstream out;
491 TraceCallStack::NamedParams namedParams;
492 namedParams["shader"] << shader;
494 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
497 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
499 std::stringstream out;
500 out << "n:" << n << " textures[";
502 TraceCallStack::NamedParams namedParams;
504 for(GLsizei i = 0; i < n; i++)
506 out << (i > 0 ? ", " : "") << textures[i];
507 std::stringstream paramName;
508 paramName << "texture[" << i << "]";
509 namedParams[paramName.str()] << textures[i];
510 mDeletedTextureIds.push_back(textures[i]);
511 mNumGeneratedTextures--;
515 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
518 inline bool CheckNoTexturesDeleted()
520 return mDeletedTextureIds.size() == 0;
523 inline bool CheckTextureDeleted(GLuint textureId)
527 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
529 if(*iter == textureId)
538 inline void ClearDeletedTextures()
540 mDeletedTextureIds.clear();
543 inline void DepthFunc(GLenum func) override
545 std::stringstream out;
546 out << std::hex << func;
548 TraceCallStack::NamedParams namedParams;
549 namedParams["func"] << std::hex << func;
551 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
554 inline void DepthMask(GLboolean flag) override
556 mLastDepthMask = flag;
559 inline bool GetLastDepthMask() const
561 return mLastDepthMask;
564 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
568 inline void DetachShader(GLuint program, GLuint shader) override
570 std::stringstream out;
571 out << program << ", " << shader;
572 TraceCallStack::NamedParams namedParams;
573 namedParams["program"] << program;
574 namedParams["shader"] << shader;
575 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
578 inline void Disable(GLenum cap) override
580 std::stringstream out;
581 out << std::hex << cap;
582 TraceCallStack::NamedParams namedParams;
583 namedParams["cap"] << std::hex << cap;
584 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
587 inline void DisableVertexAttribArray(GLuint index) override
589 std::stringstream out;
591 TraceCallStack::NamedParams namedParams;
592 namedParams["index"] << index;
593 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
594 SetVertexAttribArray(index, false);
597 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
599 std::stringstream out;
600 out << mode << ", " << first << ", " << count;
601 TraceCallStack::NamedParams namedParams;
602 namedParams["mode"] << std::hex << mode;
603 namedParams["first"] << first;
604 namedParams["count"] << count;
605 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
608 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
610 std::stringstream out;
611 out << mode << ", " << count << ", " << type << ", indices";
613 TraceCallStack::NamedParams namedParams;
614 namedParams["mode"] << std::hex << mode;
615 namedParams["count"] << count;
616 namedParams["type"] << type;
617 // Skip void pointers - are they of any use?
618 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
621 inline void Enable(GLenum cap) override
623 std::stringstream out;
624 out << std::hex << cap;
625 TraceCallStack::NamedParams namedParams;
626 namedParams["cap"] << std::hex << cap;
627 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
630 inline void EnableVertexAttribArray(GLuint index) override
632 std::stringstream out;
634 TraceCallStack::NamedParams namedParams;
635 namedParams["index"] << index;
636 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
637 SetVertexAttribArray(index, true);
640 inline void Finish(void) override
644 inline void Flush(void) override
648 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
650 if(attachment == GL_DEPTH_ATTACHMENT)
652 mFramebufferDepthAttached = true;
654 else if(attachment == GL_STENCIL_ATTACHMENT)
656 mFramebufferStencilAttached = true;
658 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
660 mFramebufferStencilAttached = true;
661 mFramebufferDepthAttached = true;
662 mFramebufferDepthStencilAttached = true;
666 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
669 mFramebufferStatus |= 4;
671 //We check 4 attachment colors
672 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
674 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
675 if((mFrameBufferColorStatus & mask) == 0)
677 mFrameBufferColorStatus |= mask;
678 ++mFramebufferColorAttachmentCount;
681 else if(attachment == GL_DEPTH_ATTACHMENT)
683 ++mFramebufferDepthAttachmentCount;
685 else if(attachment == GL_STENCIL_ATTACHMENT)
687 ++mFramebufferStencilAttachmentCount;
689 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
691 ++mFramebufferDepthAttachmentCount;
692 ++mFramebufferStencilAttachmentCount;
693 ++mFramebufferDepthStencilAttachmentCount;
697 inline void FrontFace(GLenum mode) override
702 inline void GenBuffers(GLsizei n, GLuint* buffers) override
704 // avoids an assert in GpuBuffers
705 static GLuint id = 1;
707 TraceCallStack::NamedParams namedParams;
708 namedParams["n"] << n;
710 // Allocate some buffer names
714 namedParams["buffers"] << (first ? "" : ", ") << id;
719 mBufferTrace.PushCall("GenBuffers", namedParams.str(), namedParams);
722 inline void GenerateMipmap(GLenum target) override
724 std::stringstream out;
726 TraceCallStack::NamedParams namedParams;
727 namedParams["target"] << std::hex << target;
729 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
732 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
734 for(int i = 0; i < n; i++)
736 framebuffers[i] = i + 1;
739 //Add 001 bit, this function needs to be called the first one in the chain
740 mFramebufferStatus = 1;
743 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
745 for(int i = 0; i < n; i++)
747 renderbuffers[i] = i + 1;
752 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
753 * @param[in] ids A vector containing the next IDs to be generated
755 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
757 mNextTextureIds = ids;
760 inline const std::vector<GLuint>& GetNextTextureIds()
762 return mNextTextureIds;
765 inline void GenTextures(GLsizei count, GLuint* textures) override
767 for(int i = 0; i < count; ++i)
769 if(!mNextTextureIds.empty())
771 *(textures + i) = mNextTextureIds[0];
772 mNextTextureIds.erase(mNextTextureIds.begin());
776 *(textures + i) = ++mLastAutoTextureIdUsed;
778 mNumGeneratedTextures++;
781 TraceCallStack::NamedParams namedParams;
782 namedParams["count"] << count;
784 std::stringstream out;
785 for(int i = 0; i < count; i++)
792 std::ostringstream oss;
793 oss << "indices[" << i << "]";
794 namedParams[oss.str()] << textures[i];
797 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
800 inline GLuint GetLastGenTextureId()
802 return mLastAutoTextureIdUsed;
805 inline GLuint GetNumGeneratedTextures()
807 return mNumGeneratedTextures;
810 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
812 strncpy(name, mAttribLocs[index].c_str(), 99);
813 *type = mAttribTypes[index];
816 void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms);
818 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
820 if(index < mActiveUniforms.size())
822 *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
823 *type = mActiveUniforms[index].type;
824 *size = mActiveUniforms[index].size;
828 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
832 inline int GetAttribLocation(GLuint program, const char* name) override
834 std::string check(name);
835 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
836 if(iter == mAttribLocs.end())
838 return iter - mAttribLocs.begin();
841 inline void GetBooleanv(GLenum pname, GLboolean* params) override
845 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
849 inline GLenum GetError(void) override
851 return mGetErrorResult;
854 inline void GetFloatv(GLenum pname, GLfloat* params) override
858 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
862 inline void GetIntegerv(GLenum pname, GLint* params) override
866 case GL_MAX_TEXTURE_SIZE:
869 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
872 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
873 *params = mNumBinaryFormats;
875 case GL_PROGRAM_BINARY_FORMATS_OES:
876 *params = mBinaryFormats;
878 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
879 *params = mUniformBufferOffsetAlignment;
884 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
889 *params = mLinkStatus;
891 case GL_PROGRAM_BINARY_LENGTH_OES:
892 *params = mProgramBinaryLength;
894 case GL_ACTIVE_UNIFORMS:
895 *params = mActiveUniforms.size();
897 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
900 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
903 case GL_ACTIVE_ATTRIBUTES:
904 *params = static_cast<GLint>(mAttribLocs.size());
909 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
913 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
917 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
921 case GL_COMPILE_STATUS:
922 *params = mCompileStatus;
927 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
931 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
935 inline const GLubyte* GetString(GLenum name) override
937 return mGetStringResult;
940 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
944 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
948 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
952 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
956 inline GLint GetUniformLocation(GLuint program, const char* name) override
958 ProgramUniformMap::iterator it = mUniforms.find(program);
959 if(it == mUniforms.end())
961 // Not a valid program ID
962 mGetErrorResult = GL_INVALID_OPERATION;
966 UniformIDMap& uniformIDs = it->second;
967 UniformIDMap::iterator it2 = uniformIDs.find(name);
968 if(it2 == uniformIDs.end())
970 // Uniform not found, so add it...
971 uniformIDs[name] = ++mLastUniformIdUsed;
972 return uniformIDs[name];
978 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
982 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
986 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
990 inline void Hint(GLenum target, GLenum mode) override
994 inline GLboolean IsBuffer(GLuint buffer) override
996 return mIsBufferResult;
999 inline GLboolean IsEnabled(GLenum cap) override
1001 return mIsEnabledResult;
1004 inline GLboolean IsFramebuffer(GLuint framebuffer) override
1006 return mIsFramebufferResult;
1009 inline GLboolean IsProgram(GLuint program) override
1011 return mIsProgramResult;
1014 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
1016 return mIsRenderbufferResult;
1019 inline GLboolean IsShader(GLuint shader) override
1021 return mIsShaderResult;
1024 inline GLboolean IsTexture(GLuint texture) override
1026 return mIsTextureResult;
1029 inline void LineWidth(GLfloat width) override
1033 inline void LinkProgram(GLuint program) override
1035 std::stringstream out;
1038 TraceCallStack::NamedParams namedParams;
1039 namedParams["program"] << program;
1040 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
1042 for(const auto& uniform : mActiveUniforms)
1044 std::string name = uniform.name;
1045 if(uniform.size <= 1)
1047 GetUniformLocation(program, name.c_str());
1051 // Convert single active uniform from "uBlah[0]" or "uStruct[0].element" to N versions of the same
1053 auto iter = name.find("["); // Search for index operator
1054 if(iter != std::string::npos)
1056 name = uniform.name.substr(0, iter); // Strip off index operator
1057 iter = uniform.name.find("]");
1058 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1060 suffix = uniform.name.substr(iter + 1);
1063 for(int i = 0; i < uniform.size; ++i)
1065 std::stringstream nss;
1066 nss << name << "[" << i << "]" << suffix;
1067 GetUniformLocation(program, nss.str().c_str()); // Generate N uniforms in the uniform map
1072 for(const auto& uniform : mCustomUniformData)
1074 auto iter = uniform.name.find("[");
1075 auto name = uniform.name;
1076 if(iter != std::string::npos)
1078 name = uniform.name.substr(0, iter);
1079 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1080 iter = uniform.name.find("]");
1082 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1084 suffix = uniform.name.substr(iter + 1); // If there is a suffix, it means its an element of an array of struct
1087 for(int i = 0; i < arrayCount; ++i)
1089 std::stringstream nss;
1090 nss << name << "[" << i << "]" << suffix;
1091 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1096 GetUniformLocation(program, name.c_str());
1101 inline void PixelStorei(GLenum pname, GLint param) override
1105 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1109 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1113 inline void ReleaseShaderCompiler(void) override
1117 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1121 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1125 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1127 mScissorParams.x = x;
1128 mScissorParams.y = y;
1129 mScissorParams.width = width;
1130 mScissorParams.height = height;
1132 std::stringstream out;
1133 out << x << ", " << y << ", " << width << ", " << height;
1134 TraceCallStack::NamedParams namedParams;
1135 namedParams["x"] << x;
1136 namedParams["y"] << y;
1137 namedParams["width"] << width;
1138 namedParams["height"] << height;
1139 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1142 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1146 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1148 std::string stringBuilder;
1149 for(int i = 0; i < count; ++i)
1151 stringBuilder += string[i];
1153 mShaderSources[shader] = stringBuilder;
1154 mLastShaderCompiled = shader;
1157 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1159 const std::string shaderSource = mShaderSources[shader];
1160 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1161 if(shaderSourceLength < bufsize)
1163 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1164 *length = shaderSourceLength;
1168 *length = bufsize - 1;
1169 strncpy(source, shaderSource.c_str(), *length);
1170 source[*length] = 0x0;
1174 inline std::string GetShaderSource(GLuint shader)
1176 return mShaderSources[shader];
1179 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1181 std::stringstream out;
1182 out << func << ", " << ref << ", " << mask;
1184 TraceCallStack::NamedParams namedParams;
1185 namedParams["func"] << std::hex << func;
1186 namedParams["ref"] << ref;
1187 namedParams["mask"] << mask;
1189 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1192 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1194 std::stringstream out;
1195 out << face << ", " << func << ", " << ref << ", " << mask;
1197 TraceCallStack::NamedParams namedParams;
1198 namedParams["face"] << std::hex << face;
1199 namedParams["func"] << std::hex << func;
1200 namedParams["ref"] << ref;
1201 namedParams["mask"] << mask;
1203 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1206 inline void StencilMask(GLuint mask) override
1208 std::stringstream out;
1211 TraceCallStack::NamedParams namedParams;
1212 namedParams["mask"] << mask;
1214 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1217 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1219 std::stringstream out;
1220 out << face << ", " << mask;
1222 TraceCallStack::NamedParams namedParams;
1223 namedParams["face"] << std::hex << face;
1224 namedParams["mask"] << mask;
1226 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1229 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1231 std::stringstream out;
1232 out << fail << ", " << zfail << ", " << zpass;
1234 TraceCallStack::NamedParams namedParams;
1235 namedParams["fail"] << std::hex << fail;
1236 namedParams["zfail"] << std::hex << zfail;
1237 namedParams["zpass"] << std::hex << zpass;
1239 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1242 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1244 std::stringstream out;
1245 out << face << ", " << fail << ", " << zfail << "," << zpass;
1247 TraceCallStack::NamedParams namedParams;
1248 namedParams["face"] << std::hex << face;
1249 namedParams["fail"] << std::hex << fail;
1250 namedParams["zfail"] << std::hex << zfail;
1251 namedParams["zpass"] << std::hex << zpass;
1253 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1256 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1258 std::stringstream out;
1259 out << target << ", " << level << ", " << width << ", " << height;
1261 TraceCallStack::NamedParams namedParams;
1262 namedParams["target"] << std::hex << target;
1263 namedParams["level"] << level;
1264 namedParams["internalformat"] << internalformat;
1265 namedParams["width"] << width;
1266 namedParams["height"] << height;
1267 namedParams["border"] << border;
1268 namedParams["format"] << std::hex << format;
1269 namedParams["type"] << std::hex << type;
1271 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1274 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1276 std::stringstream out;
1277 out << target << ", " << pname << ", " << param;
1279 TraceCallStack::NamedParams namedParams;
1280 namedParams["target"] << std::hex << target;
1281 namedParams["pname"] << std::hex << pname;
1282 namedParams["param"] << param;
1284 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1287 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1289 std::stringstream out;
1290 out << target << ", " << pname << ", " << params[0];
1292 TraceCallStack::NamedParams namedParams;
1293 namedParams["target"] << std::hex << target;
1294 namedParams["pname"] << std::hex << pname;
1295 namedParams["params[0]"] << params[0];
1297 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1300 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1302 std::stringstream out;
1303 out << std::hex << target << ", " << pname << ", " << param;
1304 std::string params = out.str();
1306 TraceCallStack::NamedParams namedParams;
1307 namedParams["target"] << std::hex << target;
1308 namedParams["pname"] << std::hex << pname;
1309 namedParams["param"] << param;
1310 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1313 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1315 std::stringstream out;
1316 out << target << ", " << pname << ", " << params[0];
1317 TraceCallStack::NamedParams namedParams;
1318 namedParams["target"] << std::hex << target;
1319 namedParams["pname"] << std::hex << pname;
1320 namedParams["params[0]"] << params[0];
1321 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1324 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1326 std::stringstream out;
1327 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1329 TraceCallStack::NamedParams namedParams;
1330 namedParams["target"] << std::hex << target;
1331 namedParams["level"] << level;
1332 namedParams["xoffset"] << xoffset;
1333 namedParams["yoffset"] << yoffset;
1334 namedParams["width"] << width;
1335 namedParams["height"] << height;
1336 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1339 inline void Uniform1f(GLint location, GLfloat value) override
1341 std::string params = std::to_string(value);
1342 AddUniformCallToTraceStack(location, params);
1344 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1346 mGetErrorResult = GL_INVALID_OPERATION;
1350 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1353 for(int i = 0; i < count; ++i)
1355 params = params + std::to_string(v[i]) + ",";
1358 AddUniformCallToTraceStack(location, params);
1360 for(int i = 0; i < count; ++i)
1362 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1364 mGetErrorResult = GL_INVALID_OPERATION;
1370 inline void Uniform1i(GLint location, GLint x) override
1372 std::string params = std::to_string(x);
1374 AddUniformCallToTraceStack(location, params);
1376 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1378 mGetErrorResult = GL_INVALID_OPERATION;
1382 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1384 std::ostringstream out;
1385 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1386 AddUniformCallToTraceStack(location, out.str());
1388 for(int i = 0; i < count; ++i)
1390 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1394 mGetErrorResult = GL_INVALID_OPERATION;
1400 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1402 std::string params = std::to_string(x) + "," + std::to_string(y);
1403 AddUniformCallToTraceStack(location, params);
1405 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1409 mGetErrorResult = GL_INVALID_OPERATION;
1413 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1415 std::ostringstream out;
1416 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1417 AddUniformCallToTraceStack(location, out.str());
1419 for(int i = 0; i < count; ++i)
1421 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1423 Vector2(v[2 * i], v[2 * i + 1])))
1425 mGetErrorResult = GL_INVALID_OPERATION;
1431 inline void Uniform2i(GLint location, GLint x, GLint y) override
1433 std::string params = std::to_string(x) + "," + std::to_string(y);
1434 AddUniformCallToTraceStack(location, params);
1437 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1439 std::ostringstream out;
1440 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1441 AddUniformCallToTraceStack(location, out.str());
1444 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1446 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1447 AddUniformCallToTraceStack(location, params);
1449 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1453 mGetErrorResult = GL_INVALID_OPERATION;
1457 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1459 std::ostringstream out;
1460 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1461 AddUniformCallToTraceStack(location, out.str());
1463 for(int i = 0; i < count; ++i)
1465 if(!mProgramUniforms3f.SetUniformValue(
1468 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1470 mGetErrorResult = GL_INVALID_OPERATION;
1476 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1478 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1479 AddUniformCallToTraceStack(location, params);
1482 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1484 std::ostringstream out;
1485 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1486 AddUniformCallToTraceStack(location, out.str());
1489 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1491 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1492 AddUniformCallToTraceStack(location, params);
1494 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1496 Vector4(x, y, z, w)))
1498 mGetErrorResult = GL_INVALID_OPERATION;
1502 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1504 std::ostringstream out;
1505 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1506 AddUniformCallToTraceStack(location, out.str());
1508 for(int i = 0; i < count; ++i)
1510 if(!mProgramUniforms4f.SetUniformValue(
1513 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1515 mGetErrorResult = GL_INVALID_OPERATION;
1521 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1523 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1524 AddUniformCallToTraceStack(location, params);
1527 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1529 std::ostringstream out;
1530 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1531 AddUniformCallToTraceStack(location, out.str());
1534 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1536 std::ostringstream out;
1537 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1538 AddUniformCallToTraceStack(location, out.str());
1541 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1543 std::ostringstream out;
1544 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1545 AddUniformCallToTraceStack(location, out.str());
1547 for(int i = 0; i < count; ++i)
1549 if(!mProgramUniformsMat3.SetUniformValue(
1552 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1554 mGetErrorResult = GL_INVALID_OPERATION;
1560 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1562 std::ostringstream out;
1563 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1564 AddUniformCallToTraceStack(location, out.str());
1566 for(int i = 0; i < count; ++i)
1568 if(!mProgramUniformsMat4.SetUniformValue(
1573 mGetErrorResult = GL_INVALID_OPERATION;
1579 inline void UseProgram(GLuint program) override
1581 mCurrentProgram = program;
1584 inline void ValidateProgram(GLuint program) override
1588 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1592 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1596 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1600 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1604 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1608 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1612 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1616 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1620 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1622 TraceCallStack::NamedParams namedParams;
1623 namedParams["index"] << index;
1624 namedParams["size"] << size;
1625 namedParams["type"] << std::hex << type;
1626 namedParams["normalized"] << (normalized ? "T" : "F");
1627 namedParams["stride"] << stride;
1628 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1630 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1633 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1635 TraceCallStack::NamedParams namedParams;
1636 namedParams["index"] << index;
1637 namedParams["size"] << size;
1638 namedParams["type"] << std::hex << type;
1639 namedParams["stride"] << stride;
1640 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(pointer));
1642 mBufferTrace.PushCall("VertexAttribIPointer", namedParams.str(), namedParams);
1645 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1647 std::string commaString(", ");
1648 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1650 mViewportTrace.PushCall("Viewport", params);
1655 inline void ReadBuffer(GLenum mode) override
1659 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1663 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
1667 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
1671 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1675 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1679 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
1683 inline void GenQueries(GLsizei n, GLuint* ids) override
1687 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1691 inline GLboolean IsQuery(GLuint id) override
1696 inline void BeginQuery(GLenum target, GLuint id) override
1700 inline void EndQuery(GLenum target) override
1704 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1708 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1712 inline GLboolean UnmapBuffer(GLenum target) override
1716 free(mMappedBuffer);
1717 mMappedBuffer = nullptr;
1719 return true; // false indicates corruption, nothing else.
1722 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1726 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1730 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1734 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1738 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1742 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1746 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1750 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1754 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1758 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1762 inline void FramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) override
1764 // TODO : Check it if need
1765 FramebufferTexture2D(target, attachment, textarget, texture, level);
1768 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1772 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1774 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1775 return mMappedBuffer;
1778 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1782 inline void BindVertexArray(GLuint array) override
1786 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1790 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1794 inline GLboolean IsVertexArray(GLuint array) override
1799 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1803 inline void BeginTransformFeedback(GLenum primitiveMode) override
1807 inline void EndTransformFeedback(void) override
1811 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1815 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1819 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1823 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1827 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1831 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1835 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1839 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1843 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1847 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1851 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1855 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1860 inline void Uniform1ui(GLint location, GLuint v0) override
1864 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1868 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1872 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1876 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1880 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1884 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1888 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1892 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1896 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1900 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1904 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1908 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1913 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1917 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1921 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1923 for(int i = 0; i < uniformCount; ++i)
1925 if(i < int(mActiveUniforms.size()))
1929 case GL_UNIFORM_TYPE:
1931 params[i] = mActiveUniforms[i].type;
1934 case GL_UNIFORM_SIZE:
1936 params[i] = mActiveUniforms[i].size;
1939 case GL_UNIFORM_NAME_LENGTH:
1941 params[i] = mActiveUniforms[i].name.length();
1944 case GL_UNIFORM_BLOCK_INDEX:
1949 case GL_UNIFORM_OFFSET:
1951 params[i] = mActiveUniforms[i].offset;
1954 case GL_UNIFORM_MATRIX_STRIDE:
1963 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1965 return GL_INVALID_INDEX;
1968 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1972 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1976 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1980 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1982 std::stringstream out;
1983 out << mode << ", " << first << ", " << count << ", " << instanceCount;
1984 TraceCallStack::NamedParams namedParams;
1985 namedParams["mode"] << std::hex << mode;
1986 namedParams["first"] << first;
1987 namedParams["count"] << count;
1988 namedParams["instanceCount"] << instanceCount;
1989 mDrawTrace.PushCall("DrawArraysInstanced", out.str(), namedParams);
1992 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1994 std::stringstream out;
1995 out << mode << ", " << count << ", " << type << ", " << instanceCount;
1996 TraceCallStack::NamedParams namedParams;
1997 namedParams["mode"] << std::hex << mode;
1998 namedParams["count"] << count;
1999 namedParams["type"] << std::hex << type;
2000 namedParams["indexCount"] << instanceCount;
2001 mDrawTrace.PushCall("DrawElementsInstanced", out.str(), namedParams);
2004 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
2009 inline GLboolean IsSync(GLsync sync) override
2014 inline void DeleteSync(GLsync sync) override
2018 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
2023 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
2027 inline void GetInteger64v(GLenum pname, GLint64* params) override
2031 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
2035 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
2039 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
2043 inline void GenSamplers(GLsizei count, GLuint* samplers) override
2047 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
2051 inline GLboolean IsSampler(GLuint sampler) override
2056 inline void BindSampler(GLuint unit, GLuint sampler) override
2060 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
2064 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
2068 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
2072 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
2076 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
2080 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
2084 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
2086 std::stringstream out;
2087 out << index << ", " << divisor;
2088 TraceCallStack::NamedParams namedParams;
2089 namedParams["index"] << index;
2090 namedParams["divisor"] << divisor;
2091 mBufferTrace.PushCall("VertexAttribDivisor", out.str(), namedParams);
2094 inline void BindTransformFeedback(GLenum target, GLuint id) override
2098 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
2102 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
2106 inline GLboolean IsTransformFeedback(GLuint id) override
2111 inline void PauseTransformFeedback(void) override
2115 inline void ResumeTransformFeedback(void) override
2119 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2121 mGetProgramBinaryCalled = true;
2124 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2128 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2132 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2136 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2140 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2144 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2148 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2152 inline void BlendBarrier(void)
2157 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2159 std::string name = "<not found>";
2160 bool matched = false;
2162 UniformIDMap& map = mUniforms[mCurrentProgram];
2163 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2165 if(it->second == location)
2175 mSetUniformTrace.PushCall(name, value);
2179 public: // TEST FUNCTIONS
2180 inline void SetCompileStatus(GLuint value)
2182 mCompileStatus = value;
2184 inline void SetLinkStatus(GLuint value)
2186 mLinkStatus = value;
2188 inline void SetAttribLocations(std::vector<std::string>& locs)
2192 inline void SetAttribTypes(std::vector<GLenum>& types)
2194 mAttribTypes = types;
2196 inline void SetGetErrorResult(GLenum result)
2198 mGetErrorResult = result;
2200 inline void SetGetStringResult(GLubyte* result)
2202 mGetStringResult = result;
2204 inline void SetIsBufferResult(GLboolean result)
2206 mIsBufferResult = result;
2208 inline void SetIsEnabledResult(GLboolean result)
2210 mIsEnabledResult = result;
2212 inline void SetIsFramebufferResult(GLboolean result)
2214 mIsFramebufferResult = result;
2216 inline void SetIsProgramResult(GLboolean result)
2218 mIsProgramResult = result;
2220 inline void SetIsRenderbufferResult(GLboolean result)
2222 mIsRenderbufferResult = result;
2224 inline void SetIsShaderResult(GLboolean result)
2226 mIsShaderResult = result;
2228 inline void SetIsTextureResult(GLboolean result)
2230 mIsTextureResult = result;
2232 inline void SetCheckFramebufferStatusResult(GLenum result)
2234 mCheckFramebufferStatusResult = result;
2236 inline void SetNumBinaryFormats(GLint numFormats)
2238 mNumBinaryFormats = numFormats;
2240 inline void SetBinaryFormats(GLint binaryFormats)
2242 mBinaryFormats = binaryFormats;
2244 inline void SetProgramBinaryLength(GLint length)
2246 mProgramBinaryLength = length;
2248 inline void SetUniformBufferOffsetAlignment(GLint align)
2250 mUniformBufferOffsetAlignment = align;
2252 inline bool GetVertexAttribArrayState(GLuint index)
2254 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2259 return mVertexAttribArrayState[index];
2261 inline void ClearVertexAttribArrayChanged()
2263 mVertexAttribArrayChanged = false;
2265 inline bool GetVertexAttribArrayChanged()
2267 return mVertexAttribArrayChanged;
2270 //Methods for CullFace verification
2271 inline void EnableCullFaceCallTrace(bool enable)
2273 mCullFaceTrace.Enable(enable);
2275 inline void ResetCullFaceCallStack()
2277 mCullFaceTrace.Reset();
2279 inline TraceCallStack& GetCullFaceTrace()
2281 return mCullFaceTrace;
2284 //Methods for Enable/Disable call verification
2285 inline void EnableEnableDisableCallTrace(bool enable)
2287 mEnableDisableTrace.Enable(enable);
2289 inline void ResetEnableDisableCallStack()
2291 mEnableDisableTrace.Reset();
2293 inline TraceCallStack& GetEnableDisableTrace()
2295 return mEnableDisableTrace;
2298 //Methods for Shader verification
2299 inline void EnableShaderCallTrace(bool enable)
2301 mShaderTrace.Enable(enable);
2303 inline void ResetShaderCallStack()
2305 mShaderTrace.Reset();
2307 inline TraceCallStack& GetShaderTrace()
2309 return mShaderTrace;
2312 //Methods for Texture verification
2313 inline void EnableTextureCallTrace(bool enable)
2315 mTextureTrace.Enable(enable);
2317 inline void ResetTextureCallStack()
2319 mTextureTrace.Reset();
2321 inline TraceCallStack& GetTextureTrace()
2323 return mTextureTrace;
2326 //Methods for Texture verification
2327 inline void EnableTexParameterCallTrace(bool enable)
2329 mTexParameterTrace.Enable(enable);
2331 inline void ResetTexParameterCallStack()
2333 mTexParameterTrace.Reset();
2335 inline TraceCallStack& GetTexParameterTrace()
2337 return mTexParameterTrace;
2340 //Methods for Draw verification
2341 inline void EnableDrawCallTrace(bool enable)
2343 mDrawTrace.Enable(enable);
2345 inline void ResetDrawCallStack()
2349 inline TraceCallStack& GetDrawTrace()
2354 //Methods for Depth function verification
2355 inline void EnableDepthFunctionCallTrace(bool enable)
2357 mDepthFunctionTrace.Enable(enable);
2359 inline void ResetDepthFunctionCallStack()
2361 mDepthFunctionTrace.Reset();
2363 inline TraceCallStack& GetDepthFunctionTrace()
2365 return mDepthFunctionTrace;
2368 //Methods for Stencil function verification
2369 inline void EnableStencilFunctionCallTrace(bool enable)
2371 mStencilFunctionTrace.Enable(enable);
2373 inline void ResetStencilFunctionCallStack()
2375 mStencilFunctionTrace.Reset();
2377 inline TraceCallStack& GetStencilFunctionTrace()
2379 return mStencilFunctionTrace;
2382 //Methods for Scissor verification
2383 inline void EnableScissorCallTrace(bool enable)
2385 mScissorTrace.Enable(enable);
2387 inline void ResetScissorCallStack()
2389 mScissorTrace.Reset();
2391 inline TraceCallStack& GetScissorTrace()
2393 return mScissorTrace;
2396 //Methods for Uniform function verification
2397 inline void EnableSetUniformCallTrace(bool enable)
2399 mSetUniformTrace.Enable(enable);
2401 inline void ResetSetUniformCallStack()
2403 mSetUniformTrace.Reset();
2405 inline TraceCallStack& GetSetUniformTrace()
2407 return mSetUniformTrace;
2410 //Methods for Viewport verification
2411 inline void EnableViewportCallTrace(bool enable)
2413 mViewportTrace.Enable(enable);
2415 inline void ResetViewportCallStack()
2417 mViewportTrace.Reset();
2419 inline TraceCallStack& GetViewportTrace()
2421 return mViewportTrace;
2423 inline TraceCallStack& GetBufferTrace()
2425 return mBufferTrace;
2428 template<typename T>
2429 inline bool GetUniformValue(const char* name, T& value) const
2431 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2432 program_it != mUniforms.end();
2435 const UniformIDMap& uniformIDs = program_it->second;
2437 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2438 if(uniform_it != uniformIDs.end())
2440 // found one matching uniform name, lets check the value...
2441 GLuint programId = program_it->first;
2442 GLint uniformId = uniform_it->second;
2444 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2445 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2451 template<typename T>
2452 inline bool CheckUniformValue(const char* name, const T& value) const
2454 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2455 program_it != mUniforms.end();
2458 const UniformIDMap& uniformIDs = program_it->second;
2460 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2461 if(uniform_it != uniformIDs.end())
2463 // found one matching uniform name, lets check the value...
2464 GLuint programId = program_it->first;
2465 GLint uniformId = uniform_it->second;
2467 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2468 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2470 // the value matches
2476 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2477 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2478 program_it != mUniforms.end();
2481 const UniformIDMap& uniformIDs = program_it->second;
2483 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2484 if(uniform_it != uniformIDs.end())
2486 // found one matching uniform name, lets check the value...
2487 GLuint programId = program_it->first;
2488 GLint uniformId = uniform_it->second;
2490 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2492 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2494 std::stringstream out;
2495 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2496 fprintf(stderr, "%s\n", out.str().c_str());
2503 template<typename T>
2504 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2506 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2507 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2510 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2512 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2513 program_it != mUniforms.end();
2516 const UniformIDMap& uniformIDs = program_it->second;
2518 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2519 if(uniform_it != uniformIDs.end())
2521 programId = program_it->first;
2522 uniformId = uniform_it->second;
2529 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2531 mCustomUniformData = customUniformData;
2534 inline GLuint GetLastShaderCompiled() const
2536 return mLastShaderCompiled;
2539 inline GLuint GetLastProgramCreated() const
2541 return mLastProgramIdUsed;
2544 inline GLbitfield GetLastClearMask() const
2546 return mLastClearBitMask;
2551 ATTRIB_UNKNOWN = -1,
2556 ATTRIB_BONE_WEIGHTS,
2557 ATTRIB_BONE_INDICES,
2561 struct ScissorParams
2577 // Methods to check scissor tests
2578 inline const ScissorParams& GetScissorParams() const
2580 return mScissorParams;
2583 struct ColorMaskParams
2599 inline bool GetProgramBinaryCalled() const
2601 return mGetProgramBinaryCalled;
2604 inline unsigned int GetClearCountCalled() const
2609 inline const ColorMaskParams& GetColorMaskParams() const
2611 return mColorMaskParams;
2614 typedef std::vector<size_t> BufferDataCalls;
2615 inline const BufferDataCalls& GetBufferDataCalls() const
2617 return mBufferDataCalls;
2619 inline void ResetBufferDataCalls()
2621 mBufferDataCalls.clear();
2624 typedef std::vector<size_t> BufferSubDataCalls;
2625 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2627 return mBufferSubDataCalls;
2629 inline void ResetBufferSubDataCalls()
2631 mBufferSubDataCalls.clear();
2635 GLuint mCurrentProgram;
2636 GLuint mCompileStatus;
2637 BufferDataCalls mBufferDataCalls;
2638 BufferSubDataCalls mBufferSubDataCalls;
2639 GLvoid* mMappedBuffer{nullptr};
2641 GLenum mGetErrorResult;
2642 GLubyte* mGetStringResult;
2643 GLboolean mIsBufferResult;
2644 GLboolean mIsEnabledResult;
2645 GLboolean mIsFramebufferResult;
2646 GLboolean mIsProgramResult;
2647 GLboolean mIsRenderbufferResult;
2648 GLboolean mIsShaderResult;
2649 GLboolean mIsTextureResult;
2650 GLenum mActiveTextureUnit;
2651 GLenum mCheckFramebufferStatusResult;
2652 GLint mFramebufferStatus;
2653 GLenum mFramebufferDepthAttached;
2654 GLenum mFramebufferStencilAttached;
2655 GLenum mFramebufferDepthStencilAttached;
2656 GLuint mFramebufferColorAttachmentCount;
2657 GLuint mFrameBufferColorStatus;
2658 GLuint mFramebufferDepthAttachmentCount;
2659 GLuint mFramebufferStencilAttachmentCount;
2660 GLuint mFramebufferDepthStencilAttachmentCount;
2661 GLint mNumBinaryFormats;
2662 GLint mBinaryFormats;
2663 GLint mProgramBinaryLength;
2664 GLint mUniformBufferOffsetAlignment{1};
2665 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2666 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2667 bool mGetProgramBinaryCalled;
2668 typedef std::map<GLuint, std::string> ShaderSourceMap;
2669 ShaderSourceMap mShaderSources;
2670 std::vector<std::string> mAttribLocs; // should be bound to shader
2671 std::vector<GLenum> mAttribTypes; // should be bound to shader
2672 GLuint mLastShaderCompiled;
2673 GLbitfield mLastClearBitMask;
2674 Vector4 mLastClearColor;
2675 unsigned int mClearCount;
2677 Vector4 mLastBlendColor;
2678 GLenum mLastBlendEquationRgb;
2679 GLenum mLastBlendEquationAlpha;
2680 GLenum mLastBlendFuncSrcRgb;
2681 GLenum mLastBlendFuncDstRgb;
2682 GLenum mLastBlendFuncSrcAlpha;
2683 GLenum mLastBlendFuncDstAlpha;
2685 GLboolean mLastDepthMask;
2687 // Data for manipulating the IDs returned by GenTextures
2688 GLuint mLastAutoTextureIdUsed;
2689 GLuint mNumGeneratedTextures;
2690 std::vector<GLuint> mNextTextureIds;
2691 std::vector<GLuint> mDeletedTextureIds;
2692 std::vector<GLuint> mBoundTextures;
2694 struct ActiveTextureType
2696 std::vector<GLuint> mBoundTextures;
2699 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2701 TraceCallStack mBufferTrace;
2702 TraceCallStack mCullFaceTrace;
2703 TraceCallStack mEnableDisableTrace;
2704 TraceCallStack mShaderTrace;
2705 TraceCallStack mTextureTrace;
2706 TraceCallStack mTexParameterTrace;
2707 TraceCallStack mDrawTrace;
2708 TraceCallStack mDepthFunctionTrace;
2709 TraceCallStack mStencilFunctionTrace;
2710 TraceCallStack mScissorTrace;
2711 TraceCallStack mSetUniformTrace;
2712 TraceCallStack mViewportTrace;
2714 // Shaders & Uniforms
2715 GLuint mLastShaderIdUsed;
2716 GLuint mLastProgramIdUsed{0u};
2717 GLuint mLastUniformIdUsed;
2718 typedef std::map<std::string, GLint> UniformIDMap;
2719 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2720 ProgramUniformMap mUniforms;
2721 std::vector<ActiveUniform> mActiveUniforms;
2722 std::vector<UniformData> mCustomUniformData{};
2724 template<typename T>
2725 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2728 typedef std::map<GLint, T> UniformValueMap;
2729 typedef std::map<GLuint, UniformValueMap> Map;
2731 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2738 typename Map::iterator it = Map::find(program);
2739 if(it == Map::end())
2741 // if its the first uniform for this program add it
2742 std::pair<typename Map::iterator, bool> result =
2743 Map::insert(typename Map::value_type(program, UniformValueMap()));
2747 UniformValueMap& uniforms = it->second;
2748 uniforms[uniform] = value;
2753 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2756 if(GetUniformValue(program, uniform, uniformValue))
2758 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2764 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2771 typename Map::const_iterator it = Map::find(program);
2772 if(it == Map::end())
2774 // Uniform values always initialised as 0
2779 const UniformValueMap& uniforms = it->second;
2780 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2781 if(it2 == uniforms.end())
2783 // Uniform values always initialised as 0
2787 value = it2->second;
2794 ProgramUniformValue<int> mProgramUniforms1i;
2795 ProgramUniformValue<float> mProgramUniforms1f;
2796 ProgramUniformValue<Vector2> mProgramUniforms2f;
2797 ProgramUniformValue<Vector3> mProgramUniforms3f;
2798 ProgramUniformValue<Vector4> mProgramUniforms4f;
2799 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2800 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2802 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2804 return mProgramUniforms1i;
2806 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2808 return mProgramUniforms1f;
2810 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2812 return mProgramUniforms2f;
2814 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2816 return mProgramUniforms3f;
2818 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2820 return mProgramUniforms4f;
2822 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2824 return mProgramUniformsMat4;
2826 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2828 return mProgramUniformsMat3;
2830 inline void SetVertexAttribArray(GLuint index, bool state)
2832 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2837 mVertexAttribArrayState[index] = state;
2838 mVertexAttribArrayChanged = true;
2841 ScissorParams mScissorParams;
2842 ColorMaskParams mColorMaskParams;
2846 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2852 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2858 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2860 return Vector2::ZERO;
2864 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2866 return Vector3::ZERO;
2870 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2872 return Vector4::ZERO;
2876 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2882 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2884 return Matrix3(Matrix());
2889 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2890 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2892 #endif // TEST_GL_ABSTRACTION_H