1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2022 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 uniformIDs[name];
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 auto iter = uniform.name.find("[");
995 auto name = uniform.name;
996 if(iter != std::string::npos)
998 name = uniform.name.substr(0, iter);
999 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1000 for(int i = 0; i < arrayCount; ++i)
1002 std::stringstream nss;
1003 nss << name << "[" << i << "]";
1004 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1009 GetUniformLocation(program, name.c_str());
1014 inline void PixelStorei(GLenum pname, GLint param) override
1018 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1022 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1026 inline void ReleaseShaderCompiler(void) override
1030 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1034 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1038 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1040 mScissorParams.x = x;
1041 mScissorParams.y = y;
1042 mScissorParams.width = width;
1043 mScissorParams.height = height;
1045 std::stringstream out;
1046 out << x << ", " << y << ", " << width << ", " << height;
1047 TraceCallStack::NamedParams namedParams;
1048 namedParams["x"] << x;
1049 namedParams["y"] << y;
1050 namedParams["width"] << width;
1051 namedParams["height"] << height;
1052 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1055 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1059 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1061 std::string stringBuilder;
1062 for(int i = 0; i < count; ++i)
1064 stringBuilder += string[i];
1066 mShaderSources[shader] = stringBuilder;
1067 mLastShaderCompiled = shader;
1070 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1072 const std::string shaderSource = mShaderSources[shader];
1073 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1074 if(shaderSourceLength < bufsize)
1076 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1077 *length = shaderSourceLength;
1081 *length = bufsize - 1;
1082 strncpy(source, shaderSource.c_str(), *length);
1083 source[*length] = 0x0;
1087 inline std::string GetShaderSource(GLuint shader)
1089 return mShaderSources[shader];
1092 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1094 std::stringstream out;
1095 out << func << ", " << ref << ", " << mask;
1097 TraceCallStack::NamedParams namedParams;
1098 namedParams["func"] << std::hex << func;
1099 namedParams["ref"] << ref;
1100 namedParams["mask"] << mask;
1102 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1105 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1107 std::stringstream out;
1108 out << face << ", " << func << ", " << ref << ", " << mask;
1110 TraceCallStack::NamedParams namedParams;
1111 namedParams["face"] << std::hex << face;
1112 namedParams["func"] << std::hex << func;
1113 namedParams["ref"] << ref;
1114 namedParams["mask"] << mask;
1116 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1119 inline void StencilMask(GLuint mask) override
1121 std::stringstream out;
1124 TraceCallStack::NamedParams namedParams;
1125 namedParams["mask"] << mask;
1127 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1130 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1132 std::stringstream out;
1133 out << face << ", " << mask;
1135 TraceCallStack::NamedParams namedParams;
1136 namedParams["face"] << std::hex << face;
1137 namedParams["mask"] << mask;
1139 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1142 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1144 std::stringstream out;
1145 out << fail << ", " << zfail << ", " << zpass;
1147 TraceCallStack::NamedParams namedParams;
1148 namedParams["fail"] << std::hex << fail;
1149 namedParams["zfail"] << std::hex << zfail;
1150 namedParams["zpass"] << std::hex << zpass;
1152 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1155 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1157 std::stringstream out;
1158 out << face << ", " << fail << ", " << zfail << "," << zpass;
1160 TraceCallStack::NamedParams namedParams;
1161 namedParams["face"] << std::hex << face;
1162 namedParams["fail"] << std::hex << fail;
1163 namedParams["zfail"] << std::hex << zfail;
1164 namedParams["zpass"] << std::hex << zpass;
1166 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1169 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1171 std::stringstream out;
1172 out << target << ", " << level << ", " << width << ", " << height;
1174 TraceCallStack::NamedParams namedParams;
1175 namedParams["target"] << std::hex << target;
1176 namedParams["level"] << level;
1177 namedParams["internalformat"] << internalformat;
1178 namedParams["width"] << width;
1179 namedParams["height"] << height;
1180 namedParams["border"] << border;
1181 namedParams["format"] << std::hex << format;
1182 namedParams["type"] << std::hex << type;
1184 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1187 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1189 std::stringstream out;
1190 out << target << ", " << pname << ", " << param;
1192 TraceCallStack::NamedParams namedParams;
1193 namedParams["target"] << std::hex << target;
1194 namedParams["pname"] << std::hex << pname;
1195 namedParams["param"] << param;
1197 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1200 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1202 std::stringstream out;
1203 out << target << ", " << pname << ", " << params[0];
1205 TraceCallStack::NamedParams namedParams;
1206 namedParams["target"] << std::hex << target;
1207 namedParams["pname"] << std::hex << pname;
1208 namedParams["params[0]"] << params[0];
1210 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1213 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1215 std::stringstream out;
1216 out << std::hex << target << ", " << pname << ", " << param;
1217 std::string params = out.str();
1219 TraceCallStack::NamedParams namedParams;
1220 namedParams["target"] << std::hex << target;
1221 namedParams["pname"] << std::hex << pname;
1222 namedParams["param"] << param;
1223 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1226 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1228 std::stringstream out;
1229 out << target << ", " << pname << ", " << params[0];
1230 TraceCallStack::NamedParams namedParams;
1231 namedParams["target"] << std::hex << target;
1232 namedParams["pname"] << std::hex << pname;
1233 namedParams["params[0]"] << params[0];
1234 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1237 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1239 std::stringstream out;
1240 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1242 TraceCallStack::NamedParams namedParams;
1243 namedParams["target"] << std::hex << target;
1244 namedParams["level"] << level;
1245 namedParams["xoffset"] << xoffset;
1246 namedParams["yoffset"] << yoffset;
1247 namedParams["width"] << width;
1248 namedParams["height"] << height;
1249 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1252 inline void Uniform1f(GLint location, GLfloat value) override
1254 std::string params = std::to_string(value);
1255 AddUniformCallToTraceStack(location, params);
1257 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1259 mGetErrorResult = GL_INVALID_OPERATION;
1263 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1266 for(int i = 0; i < count; ++i)
1268 params = params + std::to_string(v[i]) + ",";
1271 AddUniformCallToTraceStack(location, params);
1273 for(int i = 0; i < count; ++i)
1275 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1277 mGetErrorResult = GL_INVALID_OPERATION;
1283 inline void Uniform1i(GLint location, GLint x) override
1285 std::string params = std::to_string(x);
1287 AddUniformCallToTraceStack(location, params);
1289 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1291 mGetErrorResult = GL_INVALID_OPERATION;
1295 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1297 std::ostringstream out;
1298 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1299 AddUniformCallToTraceStack(location, out.str());
1301 for(int i = 0; i < count; ++i)
1303 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1307 mGetErrorResult = GL_INVALID_OPERATION;
1313 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1315 std::string params = std::to_string(x) + "," + std::to_string(y);
1316 AddUniformCallToTraceStack(location, params);
1318 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1322 mGetErrorResult = GL_INVALID_OPERATION;
1326 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1328 std::ostringstream out;
1329 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1330 AddUniformCallToTraceStack(location, out.str());
1332 for(int i = 0; i < count; ++i)
1334 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1336 Vector2(v[2 * i], v[2 * i + 1])))
1338 mGetErrorResult = GL_INVALID_OPERATION;
1344 inline void Uniform2i(GLint location, GLint x, GLint y) override
1346 std::string params = std::to_string(x) + "," + std::to_string(y);
1347 AddUniformCallToTraceStack(location, params);
1350 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1352 std::ostringstream out;
1353 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1354 AddUniformCallToTraceStack(location, out.str());
1357 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1359 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1360 AddUniformCallToTraceStack(location, params);
1362 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1366 mGetErrorResult = GL_INVALID_OPERATION;
1370 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1372 std::ostringstream out;
1373 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1374 AddUniformCallToTraceStack(location, out.str());
1376 for(int i = 0; i < count; ++i)
1378 if(!mProgramUniforms3f.SetUniformValue(
1381 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1383 mGetErrorResult = GL_INVALID_OPERATION;
1389 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1391 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1392 AddUniformCallToTraceStack(location, params);
1395 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1397 std::ostringstream out;
1398 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1399 AddUniformCallToTraceStack(location, out.str());
1402 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1404 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1405 AddUniformCallToTraceStack(location, params);
1407 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1409 Vector4(x, y, z, w)))
1411 mGetErrorResult = GL_INVALID_OPERATION;
1415 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1417 std::ostringstream out;
1418 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1419 AddUniformCallToTraceStack(location, out.str());
1421 for(int i = 0; i < count; ++i)
1423 if(!mProgramUniforms4f.SetUniformValue(
1426 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1428 mGetErrorResult = GL_INVALID_OPERATION;
1434 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1436 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1437 AddUniformCallToTraceStack(location, params);
1440 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1442 std::ostringstream out;
1443 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1444 AddUniformCallToTraceStack(location, out.str());
1447 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1449 std::ostringstream out;
1450 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1451 AddUniformCallToTraceStack(location, out.str());
1454 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1456 std::ostringstream out;
1457 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1458 AddUniformCallToTraceStack(location, out.str());
1460 for(int i = 0; i < count; ++i)
1462 if(!mProgramUniformsMat3.SetUniformValue(
1465 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1467 mGetErrorResult = GL_INVALID_OPERATION;
1473 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1475 std::ostringstream out;
1476 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1477 AddUniformCallToTraceStack(location, out.str());
1479 for(int i = 0; i < count; ++i)
1481 if(!mProgramUniformsMat4.SetUniformValue(
1486 mGetErrorResult = GL_INVALID_OPERATION;
1492 inline void UseProgram(GLuint program) override
1494 mCurrentProgram = program;
1497 inline void ValidateProgram(GLuint program) override
1501 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1505 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1509 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1513 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1517 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1521 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1525 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1529 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1533 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1535 TraceCallStack::NamedParams namedParams;
1536 namedParams["index"] << index;
1537 namedParams["size"] << size;
1538 namedParams["type"] << std::hex << type;
1539 namedParams["normalized"] << (normalized ? "T" : "F");
1540 namedParams["stride"] << stride;
1541 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1543 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1546 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1548 std::string commaString(", ");
1549 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1551 mViewportTrace.PushCall("Viewport", params);
1556 inline void ReadBuffer(GLenum mode) override
1560 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1564 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
1568 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
1572 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1576 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1580 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
1584 inline void GenQueries(GLsizei n, GLuint* ids) override
1588 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1592 inline GLboolean IsQuery(GLuint id) override
1597 inline void BeginQuery(GLenum target, GLuint id) override
1601 inline void EndQuery(GLenum target) override
1605 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1609 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1613 inline GLboolean UnmapBuffer(GLenum target) override
1617 free(mMappedBuffer);
1618 mMappedBuffer = nullptr;
1620 return true; // false indicates corruption, nothing else.
1623 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1627 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1631 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1635 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1639 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1643 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1647 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1651 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1655 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1659 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1663 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1667 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1669 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1670 return mMappedBuffer;
1673 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1677 inline void BindVertexArray(GLuint array) override
1681 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1685 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1689 inline GLboolean IsVertexArray(GLuint array) override
1694 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1698 inline void BeginTransformFeedback(GLenum primitiveMode) override
1702 inline void EndTransformFeedback(void) override
1706 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1710 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1714 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1718 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1722 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1726 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1730 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1734 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1738 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1742 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1746 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1750 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1754 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1759 inline void Uniform1ui(GLint location, GLuint v0) override
1763 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1767 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1771 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1775 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1779 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1783 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1787 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1791 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1795 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1799 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1803 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1807 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1812 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1816 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1820 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1824 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1826 return GL_INVALID_INDEX;
1829 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1833 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1837 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1841 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1845 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1849 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1854 inline GLboolean IsSync(GLsync sync) override
1859 inline void DeleteSync(GLsync sync) override
1863 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1868 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1872 inline void GetInteger64v(GLenum pname, GLint64* params) override
1876 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1880 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1884 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1888 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1892 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1896 inline GLboolean IsSampler(GLuint sampler) override
1901 inline void BindSampler(GLuint unit, GLuint sampler) override
1905 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1909 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1913 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1917 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1921 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1925 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1929 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1933 inline void BindTransformFeedback(GLenum target, GLuint id) override
1937 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1941 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1945 inline GLboolean IsTransformFeedback(GLuint id) override
1950 inline void PauseTransformFeedback(void) override
1954 inline void ResumeTransformFeedback(void) override
1958 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1960 mGetProgramBinaryCalled = true;
1963 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1967 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1971 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1975 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1979 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1983 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1987 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1991 inline void BlendBarrier(void)
1996 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1998 std::string name = "<not found>";
1999 bool matched = false;
2001 UniformIDMap& map = mUniforms[mCurrentProgram];
2002 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2004 if(it->second == location)
2014 mSetUniformTrace.PushCall(name, value);
2018 public: // TEST FUNCTIONS
2019 inline void SetCompileStatus(GLuint value)
2021 mCompileStatus = value;
2023 inline void SetLinkStatus(GLuint value)
2025 mLinkStatus = value;
2027 inline void SetAttribLocations(std::vector<std::string> locs)
2031 inline void SetGetErrorResult(GLenum result)
2033 mGetErrorResult = result;
2035 inline void SetGetStringResult(GLubyte* result)
2037 mGetStringResult = result;
2039 inline void SetIsBufferResult(GLboolean result)
2041 mIsBufferResult = result;
2043 inline void SetIsEnabledResult(GLboolean result)
2045 mIsEnabledResult = result;
2047 inline void SetIsFramebufferResult(GLboolean result)
2049 mIsFramebufferResult = result;
2051 inline void SetIsProgramResult(GLboolean result)
2053 mIsProgramResult = result;
2055 inline void SetIsRenderbufferResult(GLboolean result)
2057 mIsRenderbufferResult = result;
2059 inline void SetIsShaderResult(GLboolean result)
2061 mIsShaderResult = result;
2063 inline void SetIsTextureResult(GLboolean result)
2065 mIsTextureResult = result;
2067 inline void SetCheckFramebufferStatusResult(GLenum result)
2069 mCheckFramebufferStatusResult = result;
2071 inline void SetNumBinaryFormats(GLint numFormats)
2073 mNumBinaryFormats = numFormats;
2075 inline void SetBinaryFormats(GLint binaryFormats)
2077 mBinaryFormats = binaryFormats;
2079 inline void SetProgramBinaryLength(GLint length)
2081 mProgramBinaryLength = length;
2084 inline bool GetVertexAttribArrayState(GLuint index)
2086 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2091 return mVertexAttribArrayState[index];
2093 inline void ClearVertexAttribArrayChanged()
2095 mVertexAttribArrayChanged = false;
2097 inline bool GetVertexAttribArrayChanged()
2099 return mVertexAttribArrayChanged;
2102 //Methods for CullFace verification
2103 inline void EnableCullFaceCallTrace(bool enable)
2105 mCullFaceTrace.Enable(enable);
2107 inline void ResetCullFaceCallStack()
2109 mCullFaceTrace.Reset();
2111 inline TraceCallStack& GetCullFaceTrace()
2113 return mCullFaceTrace;
2116 //Methods for Enable/Disable call verification
2117 inline void EnableEnableDisableCallTrace(bool enable)
2119 mEnableDisableTrace.Enable(enable);
2121 inline void ResetEnableDisableCallStack()
2123 mEnableDisableTrace.Reset();
2125 inline TraceCallStack& GetEnableDisableTrace()
2127 return mEnableDisableTrace;
2130 //Methods for Shader verification
2131 inline void EnableShaderCallTrace(bool enable)
2133 mShaderTrace.Enable(enable);
2135 inline void ResetShaderCallStack()
2137 mShaderTrace.Reset();
2139 inline TraceCallStack& GetShaderTrace()
2141 return mShaderTrace;
2144 //Methods for Texture verification
2145 inline void EnableTextureCallTrace(bool enable)
2147 mTextureTrace.Enable(enable);
2149 inline void ResetTextureCallStack()
2151 mTextureTrace.Reset();
2153 inline TraceCallStack& GetTextureTrace()
2155 return mTextureTrace;
2158 //Methods for Texture verification
2159 inline void EnableTexParameterCallTrace(bool enable)
2161 mTexParameterTrace.Enable(enable);
2163 inline void ResetTexParameterCallStack()
2165 mTexParameterTrace.Reset();
2167 inline TraceCallStack& GetTexParameterTrace()
2169 return mTexParameterTrace;
2172 //Methods for Draw verification
2173 inline void EnableDrawCallTrace(bool enable)
2175 mDrawTrace.Enable(enable);
2177 inline void ResetDrawCallStack()
2181 inline TraceCallStack& GetDrawTrace()
2186 //Methods for Depth function verification
2187 inline void EnableDepthFunctionCallTrace(bool enable)
2189 mDepthFunctionTrace.Enable(enable);
2191 inline void ResetDepthFunctionCallStack()
2193 mDepthFunctionTrace.Reset();
2195 inline TraceCallStack& GetDepthFunctionTrace()
2197 return mDepthFunctionTrace;
2200 //Methods for Stencil function verification
2201 inline void EnableStencilFunctionCallTrace(bool enable)
2203 mStencilFunctionTrace.Enable(enable);
2205 inline void ResetStencilFunctionCallStack()
2207 mStencilFunctionTrace.Reset();
2209 inline TraceCallStack& GetStencilFunctionTrace()
2211 return mStencilFunctionTrace;
2214 //Methods for Scissor verification
2215 inline void EnableScissorCallTrace(bool enable)
2217 mScissorTrace.Enable(enable);
2219 inline void ResetScissorCallStack()
2221 mScissorTrace.Reset();
2223 inline TraceCallStack& GetScissorTrace()
2225 return mScissorTrace;
2228 //Methods for Uniform function verification
2229 inline void EnableSetUniformCallTrace(bool enable)
2231 mSetUniformTrace.Enable(enable);
2233 inline void ResetSetUniformCallStack()
2235 mSetUniformTrace.Reset();
2237 inline TraceCallStack& GetSetUniformTrace()
2239 return mSetUniformTrace;
2242 //Methods for Viewport verification
2243 inline void EnableViewportCallTrace(bool enable)
2245 mViewportTrace.Enable(enable);
2247 inline void ResetViewportCallStack()
2249 mViewportTrace.Reset();
2251 inline TraceCallStack& GetViewportTrace()
2253 return mViewportTrace;
2255 inline TraceCallStack& GetBufferTrace()
2257 return mBufferTrace;
2260 template<typename T>
2261 inline bool GetUniformValue(const char* name, T& value) const
2263 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2264 program_it != mUniforms.end();
2267 const UniformIDMap& uniformIDs = program_it->second;
2269 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2270 if(uniform_it != uniformIDs.end())
2272 // found one matching uniform name, lets check the value...
2273 GLuint programId = program_it->first;
2274 GLint uniformId = uniform_it->second;
2276 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2277 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2283 template<typename T>
2284 inline bool CheckUniformValue(const char* name, const T& value) const
2286 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2287 program_it != mUniforms.end();
2290 const UniformIDMap& uniformIDs = program_it->second;
2292 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2293 if(uniform_it != uniformIDs.end())
2295 // found one matching uniform name, lets check the value...
2296 GLuint programId = program_it->first;
2297 GLint uniformId = uniform_it->second;
2299 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2300 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2302 // the value matches
2308 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2309 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2310 program_it != mUniforms.end();
2313 const UniformIDMap& uniformIDs = program_it->second;
2315 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2316 if(uniform_it != uniformIDs.end())
2318 // found one matching uniform name, lets check the value...
2319 GLuint programId = program_it->first;
2320 GLint uniformId = uniform_it->second;
2322 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2324 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2326 std::stringstream out;
2327 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2328 fprintf(stderr, "%s\n", out.str().c_str());
2335 template<typename T>
2336 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2338 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2339 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2342 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2344 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2345 program_it != mUniforms.end();
2348 const UniformIDMap& uniformIDs = program_it->second;
2350 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2351 if(uniform_it != uniformIDs.end())
2353 programId = program_it->first;
2354 uniformId = uniform_it->second;
2361 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2363 mCustomUniformData = customUniformData;
2366 inline GLuint GetLastShaderCompiled() const
2368 return mLastShaderCompiled;
2371 inline GLuint GetLastProgramCreated() const
2373 return mLastProgramIdUsed;
2376 inline GLbitfield GetLastClearMask() const
2378 return mLastClearBitMask;
2383 ATTRIB_UNKNOWN = -1,
2388 ATTRIB_BONE_WEIGHTS,
2389 ATTRIB_BONE_INDICES,
2393 struct ScissorParams
2409 // Methods to check scissor tests
2410 inline const ScissorParams& GetScissorParams() const
2412 return mScissorParams;
2415 struct ColorMaskParams
2431 inline bool GetProgramBinaryCalled() const
2433 return mGetProgramBinaryCalled;
2436 inline unsigned int GetClearCountCalled() const
2441 inline const ColorMaskParams& GetColorMaskParams() const
2443 return mColorMaskParams;
2446 typedef std::vector<size_t> BufferDataCalls;
2447 inline const BufferDataCalls& GetBufferDataCalls() const
2449 return mBufferDataCalls;
2451 inline void ResetBufferDataCalls()
2453 mBufferDataCalls.clear();
2456 typedef std::vector<size_t> BufferSubDataCalls;
2457 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2459 return mBufferSubDataCalls;
2461 inline void ResetBufferSubDataCalls()
2463 mBufferSubDataCalls.clear();
2467 GLuint mCurrentProgram;
2468 GLuint mCompileStatus;
2469 BufferDataCalls mBufferDataCalls;
2470 BufferSubDataCalls mBufferSubDataCalls;
2471 GLvoid* mMappedBuffer{nullptr};
2473 GLenum mGetErrorResult;
2474 GLubyte* mGetStringResult;
2475 GLboolean mIsBufferResult;
2476 GLboolean mIsEnabledResult;
2477 GLboolean mIsFramebufferResult;
2478 GLboolean mIsProgramResult;
2479 GLboolean mIsRenderbufferResult;
2480 GLboolean mIsShaderResult;
2481 GLboolean mIsTextureResult;
2482 GLenum mActiveTextureUnit;
2483 GLenum mCheckFramebufferStatusResult;
2484 GLint mFramebufferStatus;
2485 GLenum mFramebufferDepthAttached;
2486 GLenum mFramebufferStencilAttached;
2487 GLuint mFramebufferColorAttachmentCount;
2488 GLuint mFrameBufferColorStatus;
2489 GLint mNumBinaryFormats;
2490 GLint mBinaryFormats;
2491 GLint mProgramBinaryLength;
2492 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2493 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2494 bool mGetProgramBinaryCalled;
2495 typedef std::map<GLuint, std::string> ShaderSourceMap;
2496 ShaderSourceMap mShaderSources;
2497 std::vector<std::string> mAttribLocs; // should be bound to shader
2498 GLuint mLastShaderCompiled;
2499 GLbitfield mLastClearBitMask;
2500 Vector4 mLastClearColor;
2501 unsigned int mClearCount;
2503 Vector4 mLastBlendColor;
2504 GLenum mLastBlendEquationRgb;
2505 GLenum mLastBlendEquationAlpha;
2506 GLenum mLastBlendFuncSrcRgb;
2507 GLenum mLastBlendFuncDstRgb;
2508 GLenum mLastBlendFuncSrcAlpha;
2509 GLenum mLastBlendFuncDstAlpha;
2511 GLboolean mLastDepthMask;
2513 // Data for manipulating the IDs returned by GenTextures
2514 GLuint mLastAutoTextureIdUsed;
2515 GLuint mNumGeneratedTextures;
2516 std::vector<GLuint> mNextTextureIds;
2517 std::vector<GLuint> mDeletedTextureIds;
2518 std::vector<GLuint> mBoundTextures;
2520 struct ActiveTextureType
2522 std::vector<GLuint> mBoundTextures;
2525 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2527 TraceCallStack mBufferTrace;
2528 TraceCallStack mCullFaceTrace;
2529 TraceCallStack mEnableDisableTrace;
2530 TraceCallStack mShaderTrace;
2531 TraceCallStack mTextureTrace;
2532 TraceCallStack mTexParameterTrace;
2533 TraceCallStack mDrawTrace;
2534 TraceCallStack mDepthFunctionTrace;
2535 TraceCallStack mStencilFunctionTrace;
2536 TraceCallStack mScissorTrace;
2537 TraceCallStack mSetUniformTrace;
2538 TraceCallStack mViewportTrace;
2540 // Shaders & Uniforms
2541 GLuint mLastShaderIdUsed;
2542 GLuint mLastProgramIdUsed{0u};
2543 GLuint mLastUniformIdUsed;
2544 typedef std::map<std::string, GLint> UniformIDMap;
2545 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2546 ProgramUniformMap mUniforms;
2547 std::vector<ActiveUniform> mActiveUniforms;
2548 std::vector<UniformData> mCustomUniformData{};
2550 template<typename T>
2551 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2554 typedef std::map<GLint, T> UniformValueMap;
2555 typedef std::map<GLuint, UniformValueMap> Map;
2557 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2564 typename Map::iterator it = Map::find(program);
2565 if(it == Map::end())
2567 // if its the first uniform for this program add it
2568 std::pair<typename Map::iterator, bool> result =
2569 Map::insert(typename Map::value_type(program, UniformValueMap()));
2573 UniformValueMap& uniforms = it->second;
2574 uniforms[uniform] = value;
2579 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2582 if(GetUniformValue(program, uniform, uniformValue))
2584 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2590 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2597 typename Map::const_iterator it = Map::find(program);
2598 if(it == Map::end())
2600 // Uniform values always initialised as 0
2605 const UniformValueMap& uniforms = it->second;
2606 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2607 if(it2 == uniforms.end())
2609 // Uniform values always initialised as 0
2613 value = it2->second;
2620 ProgramUniformValue<int> mProgramUniforms1i;
2621 ProgramUniformValue<float> mProgramUniforms1f;
2622 ProgramUniformValue<Vector2> mProgramUniforms2f;
2623 ProgramUniformValue<Vector3> mProgramUniforms3f;
2624 ProgramUniformValue<Vector4> mProgramUniforms4f;
2625 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2626 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2628 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2630 return mProgramUniforms1i;
2632 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2634 return mProgramUniforms1f;
2636 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2638 return mProgramUniforms2f;
2640 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2642 return mProgramUniforms3f;
2644 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2646 return mProgramUniforms4f;
2648 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2650 return mProgramUniformsMat4;
2652 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2654 return mProgramUniformsMat3;
2656 inline void SetVertexAttribArray(GLuint index, bool state)
2658 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2663 mVertexAttribArrayState[index] = state;
2664 mVertexAttribArrayChanged = true;
2667 ScissorParams mScissorParams;
2668 ColorMaskParams mColorMaskParams;
2672 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2678 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2684 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2686 return Vector2::ZERO;
2690 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2692 return Vector3::ZERO;
2696 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2698 return Vector4::ZERO;
2702 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2708 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2710 return Matrix3(Matrix());
2715 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2716 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2718 #endif // TEST_GL_ABSTRACTION_H