1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2021 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)
59 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
62 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
65 ~TestGlAbstraction() override;
68 void PreRender() override;
69 void PostRender() override;
71 bool IsSurfacelessContextSupported() const override;
73 bool IsAdvancedBlendEquationSupported() override;
75 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
77 std::string GetShaderVersionPrefix();
79 std::string GetVertexShaderPrefix();
81 std::string GetFragmentShaderPrefix();
83 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
87 inline void ActiveTexture(GLenum textureUnit) override
89 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
92 inline GLenum GetActiveTextureUnit() const
94 return mActiveTextureUnit + GL_TEXTURE0;
97 inline void AttachShader(GLuint program, GLuint shader) override
99 std::stringstream out;
100 out << program << ", " << shader;
102 TraceCallStack::NamedParams namedParams;
103 namedParams["program"] << program;
104 namedParams["shader"] << shader;
105 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
108 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
112 inline void BindBuffer(GLenum target, GLuint buffer) override
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);
122 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
125 mFramebufferStatus |= 2;
128 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
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.
136 inline const std::vector<GLuint>& GetBoundTextures() const
138 return mBoundTextures;
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.
146 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
148 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
152 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
154 inline void ClearBoundTextures()
156 mBoundTextures.clear();
158 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
160 mActiveTextures[i].mBoundTextures.clear();
164 inline void BindTexture(GLenum target, GLuint texture) override
166 // Record the bound textures for future checks
169 mBoundTextures.push_back(texture);
171 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
173 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
177 std::stringstream out;
178 out << std::hex << target << ", " << std::dec << texture;
180 TraceCallStack::NamedParams namedParams;
181 namedParams["target"] << std::hex << target;
182 namedParams["texture"] << texture;
184 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
187 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
189 mLastBlendColor.r = red;
190 mLastBlendColor.g = green;
191 mLastBlendColor.b = blue;
192 mLastBlendColor.a = alpha;
195 inline const Vector4& GetLastBlendColor() const
197 return mLastBlendColor;
200 inline void BlendEquation(GLenum mode) override
202 mLastBlendEquationRgb = mode;
203 mLastBlendEquationAlpha = mode;
206 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
208 mLastBlendEquationRgb = modeRgb;
209 mLastBlendEquationAlpha = modeAlpha;
212 inline GLenum GetLastBlendEquationRgb() const
214 return mLastBlendEquationRgb;
217 inline GLenum GetLastBlendEquationAlpha() const
219 return mLastBlendEquationAlpha;
222 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
224 mLastBlendFuncSrcRgb = sfactor;
225 mLastBlendFuncDstRgb = dfactor;
226 mLastBlendFuncSrcAlpha = sfactor;
227 mLastBlendFuncDstAlpha = dfactor;
230 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
232 mLastBlendFuncSrcRgb = srcRGB;
233 mLastBlendFuncDstRgb = dstRGB;
234 mLastBlendFuncSrcAlpha = srcAlpha;
235 mLastBlendFuncDstAlpha = dstAlpha;
238 inline GLenum GetLastBlendFuncSrcRgb() const
240 return mLastBlendFuncSrcRgb;
243 inline GLenum GetLastBlendFuncDstRgb() const
245 return mLastBlendFuncDstRgb;
248 inline GLenum GetLastBlendFuncSrcAlpha() const
250 return mLastBlendFuncSrcAlpha;
253 inline GLenum GetLastBlendFuncDstAlpha() const
255 return mLastBlendFuncDstAlpha;
258 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
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;
267 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
269 mBufferDataCalls.push_back(size);
272 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
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());
282 mBufferSubDataCalls.push_back(size);
285 inline GLenum CheckFramebufferStatus(GLenum target) override
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)
291 return GL_FRAMEBUFFER_COMPLETE;
294 return mCheckFramebufferStatusResult;
297 inline GLuint CheckFramebufferColorAttachmentCount()
299 return mFramebufferColorAttachmentCount;
302 inline GLenum CheckFramebufferDepthAttachment()
304 return mFramebufferDepthAttached;
307 inline GLenum CheckFramebufferStencilAttachment()
309 return mFramebufferStencilAttached;
312 inline void Clear(GLbitfield mask) override
315 mLastClearBitMask = mask;
318 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
320 mLastClearColor.r = red;
321 mLastClearColor.g = green;
322 mLastClearColor.b = blue;
323 mLastClearColor.a = alpha;
326 inline const Vector4& GetLastClearColor() const
328 return mLastClearColor;
331 inline void ClearDepthf(GLclampf depth) override
335 inline void ClearStencil(GLint s) override
337 std::stringstream out;
340 TraceCallStack::NamedParams namedParams;
341 namedParams["s"] << s;
343 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
346 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
348 mColorMaskParams.red = red;
349 mColorMaskParams.green = green;
350 mColorMaskParams.blue = blue;
351 mColorMaskParams.alpha = alpha;
354 inline void CompileShader(GLuint shader) override
356 std::stringstream out;
358 TraceCallStack::NamedParams namedParams;
359 namedParams["shader"] << shader;
361 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
364 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
366 std::stringstream out;
367 out << target << ", " << level << ", " << width << ", " << height;
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;
378 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
381 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
383 std::stringstream out;
384 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
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);
396 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
400 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
404 inline GLuint CreateProgram(void) override
406 mShaderTrace.PushCall("CreateProgram", "");
408 ++mLastProgramIdUsed;
409 mUniforms[mLastProgramIdUsed] = UniformIDMap();
410 return mLastProgramIdUsed;
413 inline GLuint CreateShader(GLenum type) override
415 std::stringstream out;
418 TraceCallStack::NamedParams namedParams;
419 namedParams["type"] << std::hex << type;
420 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
422 return ++mLastShaderIdUsed;
425 inline void CullFace(GLenum mode) override
427 std::stringstream out;
428 out << std::hex << mode;
430 TraceCallStack::NamedParams namedParams;
431 namedParams["mode"] << std::hex << mode;
433 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
436 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
440 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
444 inline void DeleteProgram(GLuint program) override
446 std::stringstream out;
449 TraceCallStack::NamedParams namedParams;
450 namedParams["program"] << program;
452 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
455 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
459 inline void DeleteShader(GLuint shader) override
461 std::stringstream out;
464 TraceCallStack::NamedParams namedParams;
465 namedParams["shader"] << shader;
467 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
470 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
472 std::stringstream out;
473 out << "n:" << n << " textures[";
475 TraceCallStack::NamedParams namedParams;
477 for(GLsizei i = 0; i < n; i++)
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--;
488 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
491 inline bool CheckNoTexturesDeleted()
493 return mDeletedTextureIds.size() == 0;
496 inline bool CheckTextureDeleted(GLuint textureId)
500 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
502 if(*iter == textureId)
511 inline void ClearDeletedTextures()
513 mDeletedTextureIds.clear();
516 inline void DepthFunc(GLenum func) override
518 std::stringstream out;
519 out << std::hex << func;
521 TraceCallStack::NamedParams namedParams;
522 namedParams["func"] << std::hex << func;
524 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
527 inline void DepthMask(GLboolean flag) override
529 mLastDepthMask = flag;
532 inline bool GetLastDepthMask() const
534 return mLastDepthMask;
537 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
541 inline void DetachShader(GLuint program, GLuint shader) override
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);
551 inline void Disable(GLenum cap) override
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);
560 inline void DisableVertexAttribArray(GLuint index) override
562 std::stringstream out;
564 TraceCallStack::NamedParams namedParams;
565 namedParams["index"] << index;
566 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
567 SetVertexAttribArray(index, false);
570 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
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);
581 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
583 std::stringstream out;
584 out << mode << ", " << count << ", " << type << ", indices";
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);
594 inline void Enable(GLenum cap) override
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);
603 inline void EnableVertexAttribArray(GLuint index) override
605 std::stringstream out;
607 TraceCallStack::NamedParams namedParams;
608 namedParams["index"] << index;
609 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
610 SetVertexAttribArray(index, true);
613 inline void Finish(void) override
617 inline void Flush(void) override
621 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
623 if(attachment == GL_DEPTH_ATTACHMENT)
625 mFramebufferDepthAttached = true;
627 else if(attachment == GL_STENCIL_ATTACHMENT)
629 mFramebufferStencilAttached = true;
631 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
633 mFramebufferStencilAttached = true;
634 mFramebufferDepthAttached = true;
638 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
641 mFramebufferStatus |= 4;
643 //We check 4 attachment colors
644 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
646 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
647 if((mFrameBufferColorStatus & mask) == 0)
649 mFrameBufferColorStatus |= mask;
650 ++mFramebufferColorAttachmentCount;
655 inline void FrontFace(GLenum mode) override
660 inline void GenBuffers(GLsizei n, GLuint* buffers) override
662 // avoids an assert in GpuBuffers
665 std::ostringstream o;
667 TraceCallStack::NamedParams namedParams;
668 namedParams["n"] << o.str();
669 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
672 inline void GenerateMipmap(GLenum target) override
674 std::stringstream out;
676 TraceCallStack::NamedParams namedParams;
677 namedParams["target"] << std::hex << target;
679 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
682 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
684 for(int i = 0; i < n; i++)
686 framebuffers[i] = i + 1;
689 //Add 001 bit, this function needs to be called the first one in the chain
690 mFramebufferStatus = 1;
693 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
695 for(int i = 0; i < n; i++)
697 renderbuffers[i] = i + 1;
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
705 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
707 mNextTextureIds = ids;
710 inline const std::vector<GLuint>& GetNextTextureIds()
712 return mNextTextureIds;
715 inline void GenTextures(GLsizei count, GLuint* textures) override
717 for(int i = 0; i < count; ++i)
719 if(!mNextTextureIds.empty())
721 *(textures + i) = mNextTextureIds[0];
722 mNextTextureIds.erase(mNextTextureIds.begin());
726 *(textures + i) = ++mLastAutoTextureIdUsed;
728 mNumGeneratedTextures++;
731 TraceCallStack::NamedParams namedParams;
732 namedParams["count"] << count;
734 std::stringstream out;
735 for(int i = 0; i < count; i++)
742 std::ostringstream oss;
743 oss << "indices[" << i << "]";
744 namedParams[oss.str()] << textures[i];
747 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
750 inline GLuint GetLastGenTextureId()
752 return mLastAutoTextureIdUsed;
755 inline GLuint GetNumGeneratedTextures()
757 return mNumGeneratedTextures;
760 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
764 inline void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms)
766 mActiveUniforms = uniforms;
769 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
771 if(index < mActiveUniforms.size())
773 *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
774 *type = mActiveUniforms[index].type;
775 *size = mActiveUniforms[index].size;
779 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
783 inline int GetAttribLocation(GLuint program, const char* name) override
785 std::string check(name);
786 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
787 if(iter == mAttribLocs.end())
789 return iter - mAttribLocs.begin();
792 inline void GetBooleanv(GLenum pname, GLboolean* params) override
796 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
800 inline GLenum GetError(void) override
802 return mGetErrorResult;
805 inline void GetFloatv(GLenum pname, GLfloat* params) override
809 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
813 inline void GetIntegerv(GLenum pname, GLint* params) override
817 case GL_MAX_TEXTURE_SIZE:
820 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
823 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
824 *params = mNumBinaryFormats;
826 case GL_PROGRAM_BINARY_FORMATS_OES:
827 *params = mBinaryFormats;
832 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
837 *params = mLinkStatus;
839 case GL_PROGRAM_BINARY_LENGTH_OES:
840 *params = mProgramBinaryLength;
842 case GL_ACTIVE_UNIFORMS:
843 *params = mActiveUniforms.size();
845 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
848 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
854 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
858 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
862 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
866 case GL_COMPILE_STATUS:
867 *params = mCompileStatus;
872 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
876 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
880 inline const GLubyte* GetString(GLenum name) override
882 return mGetStringResult;
885 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
889 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
893 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
897 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
901 inline GLint GetUniformLocation(GLuint program, const char* name) override
903 ProgramUniformMap::iterator it = mUniforms.find(program);
904 if(it == mUniforms.end())
906 // Not a valid program ID
907 mGetErrorResult = GL_INVALID_OPERATION;
911 UniformIDMap& uniformIDs = it->second;
912 UniformIDMap::iterator it2 = uniformIDs.find(name);
913 if(it2 == uniformIDs.end())
915 // Uniform not found, so add it...
916 uniformIDs[name] = mLastUniformIdUsed++;
917 return mLastUniformIdUsed;
923 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
927 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
931 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
935 inline void Hint(GLenum target, GLenum mode) override
939 inline GLboolean IsBuffer(GLuint buffer) override
941 return mIsBufferResult;
944 inline GLboolean IsEnabled(GLenum cap) override
946 return mIsEnabledResult;
949 inline GLboolean IsFramebuffer(GLuint framebuffer) override
951 return mIsFramebufferResult;
954 inline GLboolean IsProgram(GLuint program) override
956 return mIsProgramResult;
959 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
961 return mIsRenderbufferResult;
964 inline GLboolean IsShader(GLuint shader) override
966 return mIsShaderResult;
969 inline GLboolean IsTexture(GLuint texture) override
971 return mIsTextureResult;
974 inline void LineWidth(GLfloat width) override
978 inline void LinkProgram(GLuint program) override
980 std::stringstream out;
983 TraceCallStack::NamedParams namedParams;
984 namedParams["program"] << program;
985 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
987 for(const auto& uniform : mActiveUniforms)
989 GetUniformLocation(program, uniform.name.c_str());
992 for(const auto& uniform : mCustomUniformData)
994 GetUniformLocation(program, uniform.name.c_str());
998 inline void PixelStorei(GLenum pname, GLint param) override
1002 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1006 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1010 inline void ReleaseShaderCompiler(void) override
1014 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1018 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1022 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1024 mScissorParams.x = x;
1025 mScissorParams.y = y;
1026 mScissorParams.width = width;
1027 mScissorParams.height = height;
1029 std::stringstream out;
1030 out << x << ", " << y << ", " << width << ", " << height;
1031 TraceCallStack::NamedParams namedParams;
1032 namedParams["x"] << x;
1033 namedParams["y"] << y;
1034 namedParams["width"] << width;
1035 namedParams["height"] << height;
1036 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1039 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1043 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1045 std::string stringBuilder;
1046 for(int i = 0; i < count; ++i)
1048 stringBuilder += string[i];
1050 mShaderSources[shader] = stringBuilder;
1051 mLastShaderCompiled = shader;
1054 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1056 const std::string shaderSource = mShaderSources[shader];
1057 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1058 if(shaderSourceLength < bufsize)
1060 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1061 *length = shaderSourceLength;
1065 *length = bufsize - 1;
1066 strncpy(source, shaderSource.c_str(), *length);
1067 source[*length] = 0x0;
1071 inline std::string GetShaderSource(GLuint shader)
1073 return mShaderSources[shader];
1076 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1078 std::stringstream out;
1079 out << func << ", " << ref << ", " << mask;
1081 TraceCallStack::NamedParams namedParams;
1082 namedParams["func"] << std::hex << func;
1083 namedParams["ref"] << ref;
1084 namedParams["mask"] << mask;
1086 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1089 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1091 std::stringstream out;
1092 out << face << ", " << func << ", " << ref << ", " << mask;
1094 TraceCallStack::NamedParams namedParams;
1095 namedParams["face"] << std::hex << face;
1096 namedParams["func"] << std::hex << func;
1097 namedParams["ref"] << ref;
1098 namedParams["mask"] << mask;
1100 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1103 inline void StencilMask(GLuint mask) override
1105 std::stringstream out;
1108 TraceCallStack::NamedParams namedParams;
1109 namedParams["mask"] << mask;
1111 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1114 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1116 std::stringstream out;
1117 out << face << ", " << mask;
1119 TraceCallStack::NamedParams namedParams;
1120 namedParams["face"] << std::hex << face;
1121 namedParams["mask"] << mask;
1123 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1126 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1128 std::stringstream out;
1129 out << fail << ", " << zfail << ", " << zpass;
1131 TraceCallStack::NamedParams namedParams;
1132 namedParams["fail"] << std::hex << fail;
1133 namedParams["zfail"] << std::hex << zfail;
1134 namedParams["zpass"] << std::hex << zpass;
1136 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1139 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1141 std::stringstream out;
1142 out << face << ", " << fail << ", " << zfail << "," << zpass;
1144 TraceCallStack::NamedParams namedParams;
1145 namedParams["face"] << std::hex << face;
1146 namedParams["fail"] << std::hex << fail;
1147 namedParams["zfail"] << std::hex << zfail;
1148 namedParams["zpass"] << std::hex << zpass;
1150 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1153 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1155 std::stringstream out;
1156 out << target << ", " << level << ", " << width << ", " << height;
1158 TraceCallStack::NamedParams namedParams;
1159 namedParams["target"] << std::hex << target;
1160 namedParams["level"] << level;
1161 namedParams["internalformat"] << internalformat;
1162 namedParams["width"] << width;
1163 namedParams["height"] << height;
1164 namedParams["border"] << border;
1165 namedParams["format"] << std::hex << format;
1166 namedParams["type"] << std::hex << type;
1168 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1171 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1173 std::stringstream out;
1174 out << target << ", " << pname << ", " << param;
1176 TraceCallStack::NamedParams namedParams;
1177 namedParams["target"] << std::hex << target;
1178 namedParams["pname"] << std::hex << pname;
1179 namedParams["param"] << param;
1181 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1184 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1186 std::stringstream out;
1187 out << target << ", " << pname << ", " << params[0];
1189 TraceCallStack::NamedParams namedParams;
1190 namedParams["target"] << std::hex << target;
1191 namedParams["pname"] << std::hex << pname;
1192 namedParams["params[0]"] << params[0];
1194 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1197 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1199 std::stringstream out;
1200 out << std::hex << target << ", " << pname << ", " << param;
1201 std::string params = out.str();
1203 TraceCallStack::NamedParams namedParams;
1204 namedParams["target"] << std::hex << target;
1205 namedParams["pname"] << std::hex << pname;
1206 namedParams["param"] << param;
1207 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1210 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1212 std::stringstream out;
1213 out << target << ", " << pname << ", " << params[0];
1214 TraceCallStack::NamedParams namedParams;
1215 namedParams["target"] << std::hex << target;
1216 namedParams["pname"] << std::hex << pname;
1217 namedParams["params[0]"] << params[0];
1218 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1221 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1223 std::stringstream out;
1224 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1226 TraceCallStack::NamedParams namedParams;
1227 namedParams["target"] << std::hex << target;
1228 namedParams["level"] << level;
1229 namedParams["xoffset"] << xoffset;
1230 namedParams["yoffset"] << yoffset;
1231 namedParams["width"] << width;
1232 namedParams["height"] << height;
1233 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1236 inline void Uniform1f(GLint location, GLfloat value) override
1238 std::string params = std::to_string(value);
1239 AddUniformCallToTraceStack(location, params);
1241 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1243 mGetErrorResult = GL_INVALID_OPERATION;
1247 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1250 for(int i = 0; i < count; ++i)
1252 params = params + std::to_string(v[i]) + ",";
1255 AddUniformCallToTraceStack(location, params);
1257 for(int i = 0; i < count; ++i)
1259 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1261 mGetErrorResult = GL_INVALID_OPERATION;
1267 inline void Uniform1i(GLint location, GLint x) override
1269 std::string params = std::to_string(x);
1271 AddUniformCallToTraceStack(location, params);
1273 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1275 mGetErrorResult = GL_INVALID_OPERATION;
1279 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1281 std::ostringstream out;
1282 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1283 AddUniformCallToTraceStack(location, out.str());
1285 for(int i = 0; i < count; ++i)
1287 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1291 mGetErrorResult = GL_INVALID_OPERATION;
1297 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1299 std::string params = std::to_string(x) + "," + std::to_string(y);
1300 AddUniformCallToTraceStack(location, params);
1302 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1306 mGetErrorResult = GL_INVALID_OPERATION;
1310 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1312 std::ostringstream out;
1313 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1314 AddUniformCallToTraceStack(location, out.str());
1316 for(int i = 0; i < count; ++i)
1318 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1320 Vector2(v[2 * i], v[2 * i + 1])))
1322 mGetErrorResult = GL_INVALID_OPERATION;
1328 inline void Uniform2i(GLint location, GLint x, GLint y) override
1330 std::string params = std::to_string(x) + "," + std::to_string(y);
1331 AddUniformCallToTraceStack(location, params);
1334 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1336 std::ostringstream out;
1337 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1338 AddUniformCallToTraceStack(location, out.str());
1341 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1343 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1344 AddUniformCallToTraceStack(location, params);
1346 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1350 mGetErrorResult = GL_INVALID_OPERATION;
1354 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1356 std::ostringstream out;
1357 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1358 AddUniformCallToTraceStack(location, out.str());
1360 for(int i = 0; i < count; ++i)
1362 if(!mProgramUniforms3f.SetUniformValue(
1365 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1367 mGetErrorResult = GL_INVALID_OPERATION;
1373 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1375 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1376 AddUniformCallToTraceStack(location, params);
1379 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1381 std::ostringstream out;
1382 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1383 AddUniformCallToTraceStack(location, out.str());
1386 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1388 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1389 AddUniformCallToTraceStack(location, params);
1391 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1393 Vector4(x, y, z, w)))
1395 mGetErrorResult = GL_INVALID_OPERATION;
1399 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1401 std::ostringstream out;
1402 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1403 AddUniformCallToTraceStack(location, out.str());
1405 for(int i = 0; i < count; ++i)
1407 if(!mProgramUniforms4f.SetUniformValue(
1410 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1412 mGetErrorResult = GL_INVALID_OPERATION;
1418 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1420 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1421 AddUniformCallToTraceStack(location, params);
1424 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1426 std::ostringstream out;
1427 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1428 AddUniformCallToTraceStack(location, out.str());
1431 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1433 std::ostringstream out;
1434 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1435 AddUniformCallToTraceStack(location, out.str());
1438 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1440 std::ostringstream out;
1441 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1442 AddUniformCallToTraceStack(location, out.str());
1444 for(int i = 0; i < count; ++i)
1446 if(!mProgramUniformsMat3.SetUniformValue(
1449 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1451 mGetErrorResult = GL_INVALID_OPERATION;
1457 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1459 std::ostringstream out;
1460 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1461 AddUniformCallToTraceStack(location, out.str());
1463 for(int i = 0; i < count; ++i)
1465 if(!mProgramUniformsMat4.SetUniformValue(
1470 mGetErrorResult = GL_INVALID_OPERATION;
1476 inline void UseProgram(GLuint program) override
1478 mCurrentProgram = program;
1481 inline void ValidateProgram(GLuint program) override
1485 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1489 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1493 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1497 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1501 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1505 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1509 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1513 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1517 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1519 TraceCallStack::NamedParams namedParams;
1520 namedParams["index"] << index;
1521 namedParams["size"] << size;
1522 namedParams["type"] << std::hex << type;
1523 namedParams["normalized"] << (normalized ? "T" : "F");
1524 namedParams["stride"] << stride;
1525 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1527 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1530 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1532 std::string commaString(", ");
1533 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1535 mViewportTrace.PushCall("Viewport", params);
1540 inline void ReadBuffer(GLenum mode) override
1544 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1548 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
1552 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
1556 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1560 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1564 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
1568 inline void GenQueries(GLsizei n, GLuint* ids) override
1572 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1576 inline GLboolean IsQuery(GLuint id) override
1581 inline void BeginQuery(GLenum target, GLuint id) override
1585 inline void EndQuery(GLenum target) override
1589 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1593 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1597 inline GLboolean UnmapBuffer(GLenum target) override
1601 free(mMappedBuffer);
1602 mMappedBuffer = nullptr;
1604 return true; // false indicates corruption, nothing else.
1607 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1611 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1615 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1619 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1623 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1627 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1631 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1635 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1639 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1643 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1647 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1651 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1653 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1654 return mMappedBuffer;
1657 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1661 inline void BindVertexArray(GLuint array) override
1665 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1669 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1673 inline GLboolean IsVertexArray(GLuint array) override
1678 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1682 inline void BeginTransformFeedback(GLenum primitiveMode) override
1686 inline void EndTransformFeedback(void) override
1690 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1694 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1698 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1702 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1706 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1710 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1714 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1718 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1722 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1726 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1730 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1734 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1738 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1743 inline void Uniform1ui(GLint location, GLuint v0) override
1747 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1751 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1755 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1759 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1763 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1767 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1771 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1775 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1779 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1783 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1787 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1791 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1796 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1800 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1804 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1808 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1810 return GL_INVALID_INDEX;
1813 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1817 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1821 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1825 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1829 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1833 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1838 inline GLboolean IsSync(GLsync sync) override
1843 inline void DeleteSync(GLsync sync) override
1847 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1852 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1856 inline void GetInteger64v(GLenum pname, GLint64* params) override
1860 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1864 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1868 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1872 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1876 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1880 inline GLboolean IsSampler(GLuint sampler) override
1885 inline void BindSampler(GLuint unit, GLuint sampler) override
1889 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1893 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1897 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1901 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1905 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1909 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1913 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1917 inline void BindTransformFeedback(GLenum target, GLuint id) override
1921 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1925 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1929 inline GLboolean IsTransformFeedback(GLuint id) override
1934 inline void PauseTransformFeedback(void) override
1938 inline void ResumeTransformFeedback(void) override
1942 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1944 mGetProgramBinaryCalled = true;
1947 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1951 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1955 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1959 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1963 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1967 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1971 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1975 inline void BlendBarrier(void)
1980 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1982 std::string name = "<not found>";
1983 bool matched = false;
1985 UniformIDMap& map = mUniforms[mCurrentProgram];
1986 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1988 if(it->second == location)
1998 mSetUniformTrace.PushCall(name, value);
2002 public: // TEST FUNCTIONS
2003 inline void SetCompileStatus(GLuint value)
2005 mCompileStatus = value;
2007 inline void SetLinkStatus(GLuint value)
2009 mLinkStatus = value;
2011 inline void SetAttribLocations(std::vector<std::string> locs)
2015 inline void SetGetErrorResult(GLenum result)
2017 mGetErrorResult = result;
2019 inline void SetGetStringResult(GLubyte* result)
2021 mGetStringResult = result;
2023 inline void SetIsBufferResult(GLboolean result)
2025 mIsBufferResult = result;
2027 inline void SetIsEnabledResult(GLboolean result)
2029 mIsEnabledResult = result;
2031 inline void SetIsFramebufferResult(GLboolean result)
2033 mIsFramebufferResult = result;
2035 inline void SetIsProgramResult(GLboolean result)
2037 mIsProgramResult = result;
2039 inline void SetIsRenderbufferResult(GLboolean result)
2041 mIsRenderbufferResult = result;
2043 inline void SetIsShaderResult(GLboolean result)
2045 mIsShaderResult = result;
2047 inline void SetIsTextureResult(GLboolean result)
2049 mIsTextureResult = result;
2051 inline void SetCheckFramebufferStatusResult(GLenum result)
2053 mCheckFramebufferStatusResult = result;
2055 inline void SetNumBinaryFormats(GLint numFormats)
2057 mNumBinaryFormats = numFormats;
2059 inline void SetBinaryFormats(GLint binaryFormats)
2061 mBinaryFormats = binaryFormats;
2063 inline void SetProgramBinaryLength(GLint length)
2065 mProgramBinaryLength = length;
2068 inline bool GetVertexAttribArrayState(GLuint index)
2070 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2075 return mVertexAttribArrayState[index];
2077 inline void ClearVertexAttribArrayChanged()
2079 mVertexAttribArrayChanged = false;
2081 inline bool GetVertexAttribArrayChanged()
2083 return mVertexAttribArrayChanged;
2086 //Methods for CullFace verification
2087 inline void EnableCullFaceCallTrace(bool enable)
2089 mCullFaceTrace.Enable(enable);
2091 inline void ResetCullFaceCallStack()
2093 mCullFaceTrace.Reset();
2095 inline TraceCallStack& GetCullFaceTrace()
2097 return mCullFaceTrace;
2100 //Methods for Enable/Disable call verification
2101 inline void EnableEnableDisableCallTrace(bool enable)
2103 mEnableDisableTrace.Enable(enable);
2105 inline void ResetEnableDisableCallStack()
2107 mEnableDisableTrace.Reset();
2109 inline TraceCallStack& GetEnableDisableTrace()
2111 return mEnableDisableTrace;
2114 //Methods for Shader verification
2115 inline void EnableShaderCallTrace(bool enable)
2117 mShaderTrace.Enable(enable);
2119 inline void ResetShaderCallStack()
2121 mShaderTrace.Reset();
2123 inline TraceCallStack& GetShaderTrace()
2125 return mShaderTrace;
2128 //Methods for Texture verification
2129 inline void EnableTextureCallTrace(bool enable)
2131 mTextureTrace.Enable(enable);
2133 inline void ResetTextureCallStack()
2135 mTextureTrace.Reset();
2137 inline TraceCallStack& GetTextureTrace()
2139 return mTextureTrace;
2142 //Methods for Texture verification
2143 inline void EnableTexParameterCallTrace(bool enable)
2145 mTexParameterTrace.Enable(enable);
2147 inline void ResetTexParameterCallStack()
2149 mTexParameterTrace.Reset();
2151 inline TraceCallStack& GetTexParameterTrace()
2153 return mTexParameterTrace;
2156 //Methods for Draw verification
2157 inline void EnableDrawCallTrace(bool enable)
2159 mDrawTrace.Enable(enable);
2161 inline void ResetDrawCallStack()
2165 inline TraceCallStack& GetDrawTrace()
2170 //Methods for Depth function verification
2171 inline void EnableDepthFunctionCallTrace(bool enable)
2173 mDepthFunctionTrace.Enable(enable);
2175 inline void ResetDepthFunctionCallStack()
2177 mDepthFunctionTrace.Reset();
2179 inline TraceCallStack& GetDepthFunctionTrace()
2181 return mDepthFunctionTrace;
2184 //Methods for Stencil function verification
2185 inline void EnableStencilFunctionCallTrace(bool enable)
2187 mStencilFunctionTrace.Enable(enable);
2189 inline void ResetStencilFunctionCallStack()
2191 mStencilFunctionTrace.Reset();
2193 inline TraceCallStack& GetStencilFunctionTrace()
2195 return mStencilFunctionTrace;
2198 //Methods for Scissor verification
2199 inline void EnableScissorCallTrace(bool enable)
2201 mScissorTrace.Enable(enable);
2203 inline void ResetScissorCallStack()
2205 mScissorTrace.Reset();
2207 inline TraceCallStack& GetScissorTrace()
2209 return mScissorTrace;
2212 //Methods for Uniform function verification
2213 inline void EnableSetUniformCallTrace(bool enable)
2215 mSetUniformTrace.Enable(enable);
2217 inline void ResetSetUniformCallStack()
2219 mSetUniformTrace.Reset();
2221 inline TraceCallStack& GetSetUniformTrace()
2223 return mSetUniformTrace;
2226 //Methods for Viewport verification
2227 inline void EnableViewportCallTrace(bool enable)
2229 mViewportTrace.Enable(enable);
2231 inline void ResetViewportCallStack()
2233 mViewportTrace.Reset();
2235 inline TraceCallStack& GetViewportTrace()
2237 return mViewportTrace;
2239 inline TraceCallStack& GetBufferTrace()
2241 return mBufferTrace;
2244 template<typename T>
2245 inline bool GetUniformValue(const char* name, T& value) const
2247 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2248 program_it != mUniforms.end();
2251 const UniformIDMap& uniformIDs = program_it->second;
2253 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2254 if(uniform_it != uniformIDs.end())
2256 // found one matching uniform name, lets check the value...
2257 GLuint programId = program_it->first;
2258 GLint uniformId = uniform_it->second;
2260 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2261 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2267 template<typename T>
2268 inline bool CheckUniformValue(const char* name, const T& value) const
2270 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2271 program_it != mUniforms.end();
2274 const UniformIDMap& uniformIDs = program_it->second;
2276 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2277 if(uniform_it != uniformIDs.end())
2279 // found one matching uniform name, lets check the value...
2280 GLuint programId = program_it->first;
2281 GLint uniformId = uniform_it->second;
2283 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2284 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2286 // the value matches
2292 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2293 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2294 program_it != mUniforms.end();
2297 const UniformIDMap& uniformIDs = program_it->second;
2299 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2300 if(uniform_it != uniformIDs.end())
2302 // found one matching uniform name, lets check the value...
2303 GLuint programId = program_it->first;
2304 GLint uniformId = uniform_it->second;
2306 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2308 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2310 std::stringstream out;
2311 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2312 fprintf(stderr, "%s\n", out.str().c_str());
2319 template<typename T>
2320 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2322 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2323 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2326 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2328 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2329 program_it != mUniforms.end();
2332 const UniformIDMap& uniformIDs = program_it->second;
2334 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2335 if(uniform_it != uniformIDs.end())
2337 programId = program_it->first;
2338 uniformId = uniform_it->second;
2345 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2347 mCustomUniformData = customUniformData;
2350 inline GLuint GetLastShaderCompiled() const
2352 return mLastShaderCompiled;
2355 inline GLuint GetLastProgramCreated() const
2357 return mLastProgramIdUsed;
2360 inline GLbitfield GetLastClearMask() const
2362 return mLastClearBitMask;
2367 ATTRIB_UNKNOWN = -1,
2372 ATTRIB_BONE_WEIGHTS,
2373 ATTRIB_BONE_INDICES,
2377 struct ScissorParams
2393 // Methods to check scissor tests
2394 inline const ScissorParams& GetScissorParams() const
2396 return mScissorParams;
2399 struct ColorMaskParams
2415 inline bool GetProgramBinaryCalled() const
2417 return mGetProgramBinaryCalled;
2420 inline unsigned int GetClearCountCalled() const
2425 inline const ColorMaskParams& GetColorMaskParams() const
2427 return mColorMaskParams;
2430 typedef std::vector<size_t> BufferDataCalls;
2431 inline const BufferDataCalls& GetBufferDataCalls() const
2433 return mBufferDataCalls;
2435 inline void ResetBufferDataCalls()
2437 mBufferDataCalls.clear();
2440 typedef std::vector<size_t> BufferSubDataCalls;
2441 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2443 return mBufferSubDataCalls;
2445 inline void ResetBufferSubDataCalls()
2447 mBufferSubDataCalls.clear();
2451 GLuint mCurrentProgram;
2452 GLuint mCompileStatus;
2453 BufferDataCalls mBufferDataCalls;
2454 BufferSubDataCalls mBufferSubDataCalls;
2455 GLvoid* mMappedBuffer{nullptr};
2457 GLenum mGetErrorResult;
2458 GLubyte* mGetStringResult;
2459 GLboolean mIsBufferResult;
2460 GLboolean mIsEnabledResult;
2461 GLboolean mIsFramebufferResult;
2462 GLboolean mIsProgramResult;
2463 GLboolean mIsRenderbufferResult;
2464 GLboolean mIsShaderResult;
2465 GLboolean mIsTextureResult;
2466 GLenum mActiveTextureUnit;
2467 GLenum mCheckFramebufferStatusResult;
2468 GLint mFramebufferStatus;
2469 GLenum mFramebufferDepthAttached;
2470 GLenum mFramebufferStencilAttached;
2471 GLuint mFramebufferColorAttachmentCount;
2472 GLuint mFrameBufferColorStatus;
2473 GLint mNumBinaryFormats;
2474 GLint mBinaryFormats;
2475 GLint mProgramBinaryLength;
2476 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2477 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2478 bool mGetProgramBinaryCalled;
2479 typedef std::map<GLuint, std::string> ShaderSourceMap;
2480 ShaderSourceMap mShaderSources;
2481 std::vector<std::string> mAttribLocs; // should be bound to shader
2482 GLuint mLastShaderCompiled;
2483 GLbitfield mLastClearBitMask;
2484 Vector4 mLastClearColor;
2485 unsigned int mClearCount;
2487 Vector4 mLastBlendColor;
2488 GLenum mLastBlendEquationRgb;
2489 GLenum mLastBlendEquationAlpha;
2490 GLenum mLastBlendFuncSrcRgb;
2491 GLenum mLastBlendFuncDstRgb;
2492 GLenum mLastBlendFuncSrcAlpha;
2493 GLenum mLastBlendFuncDstAlpha;
2495 GLboolean mLastDepthMask;
2497 // Data for manipulating the IDs returned by GenTextures
2498 GLuint mLastAutoTextureIdUsed;
2499 GLuint mNumGeneratedTextures;
2500 std::vector<GLuint> mNextTextureIds;
2501 std::vector<GLuint> mDeletedTextureIds;
2502 std::vector<GLuint> mBoundTextures;
2504 struct ActiveTextureType
2506 std::vector<GLuint> mBoundTextures;
2509 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2511 TraceCallStack mBufferTrace;
2512 TraceCallStack mCullFaceTrace;
2513 TraceCallStack mEnableDisableTrace;
2514 TraceCallStack mShaderTrace;
2515 TraceCallStack mTextureTrace;
2516 TraceCallStack mTexParameterTrace;
2517 TraceCallStack mDrawTrace;
2518 TraceCallStack mDepthFunctionTrace;
2519 TraceCallStack mStencilFunctionTrace;
2520 TraceCallStack mScissorTrace;
2521 TraceCallStack mSetUniformTrace;
2522 TraceCallStack mViewportTrace;
2524 // Shaders & Uniforms
2525 GLuint mLastShaderIdUsed;
2526 GLuint mLastProgramIdUsed{0u};
2527 GLuint mLastUniformIdUsed;
2528 typedef std::map<std::string, GLint> UniformIDMap;
2529 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2530 ProgramUniformMap mUniforms;
2531 std::vector<ActiveUniform> mActiveUniforms;
2532 std::vector<UniformData> mCustomUniformData{};
2534 template<typename T>
2535 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2538 typedef std::map<GLint, T> UniformValueMap;
2539 typedef std::map<GLuint, UniformValueMap> Map;
2541 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2548 typename Map::iterator it = Map::find(program);
2549 if(it == Map::end())
2551 // if its the first uniform for this program add it
2552 std::pair<typename Map::iterator, bool> result =
2553 Map::insert(typename Map::value_type(program, UniformValueMap()));
2557 UniformValueMap& uniforms = it->second;
2558 uniforms[uniform] = value;
2563 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2566 if(GetUniformValue(program, uniform, uniformValue))
2568 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2574 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2581 typename Map::const_iterator it = Map::find(program);
2582 if(it == Map::end())
2584 // Uniform values always initialised as 0
2589 const UniformValueMap& uniforms = it->second;
2590 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2591 if(it2 == uniforms.end())
2593 // Uniform values always initialised as 0
2597 value = it2->second;
2604 ProgramUniformValue<int> mProgramUniforms1i;
2605 ProgramUniformValue<float> mProgramUniforms1f;
2606 ProgramUniformValue<Vector2> mProgramUniforms2f;
2607 ProgramUniformValue<Vector3> mProgramUniforms3f;
2608 ProgramUniformValue<Vector4> mProgramUniforms4f;
2609 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2610 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2612 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2614 return mProgramUniforms1i;
2616 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2618 return mProgramUniforms1f;
2620 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2622 return mProgramUniforms2f;
2624 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2626 return mProgramUniforms3f;
2628 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2630 return mProgramUniforms4f;
2632 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2634 return mProgramUniformsMat4;
2636 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2638 return mProgramUniformsMat3;
2640 inline void SetVertexAttribArray(GLuint index, bool state)
2642 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2647 mVertexAttribArrayState[index] = state;
2648 mVertexAttribArrayChanged = true;
2651 ScissorParams mScissorParams;
2652 ColorMaskParams mColorMaskParams;
2656 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2662 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2668 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2670 return Vector2::ZERO;
2674 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2676 return Vector3::ZERO;
2680 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2682 return Vector4::ZERO;
2686 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2692 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2694 return Matrix3(Matrix());
2699 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2700 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2702 #endif // TEST_GL_ABSTRACTION_H