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>
41 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
44 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
47 ~TestGlAbstraction() override;
50 void PreRender() override;
51 void PostRender() override;
53 bool IsSurfacelessContextSupported() const override;
55 bool IsAdvancedBlendEquationSupported() override;
57 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
59 std::string GetShaderVersionPrefix();
61 std::string GetVertexShaderPrefix();
63 std::string GetFragmentShaderPrefix();
65 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
69 inline void ActiveTexture(GLenum textureUnit) override
71 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
74 inline GLenum GetActiveTextureUnit() const
76 return mActiveTextureUnit + GL_TEXTURE0;
79 inline void AttachShader(GLuint program, GLuint shader) override
81 std::stringstream out;
82 out << program << ", " << shader;
84 TraceCallStack::NamedParams namedParams;
85 namedParams["program"] << program;
86 namedParams["shader"] << shader;
87 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
90 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
94 inline void BindBuffer(GLenum target, GLuint buffer) override
97 o << std::hex << target << ", " << buffer;
98 TraceCallStack::NamedParams namedParams;
99 namedParams["target"] << target;
100 namedParams["buffer"] << buffer;
101 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
104 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
107 mFramebufferStatus |= 2;
110 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
115 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
116 * @return A vector containing the IDs that were bound.
118 inline const std::vector<GLuint>& GetBoundTextures() const
120 return mBoundTextures;
124 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
125 * @param[in] activeTextureUnit The specific active texture unit.
126 * @return A vector containing the IDs that were bound.
128 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
130 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
134 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
136 inline void ClearBoundTextures()
138 mBoundTextures.clear();
140 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
142 mActiveTextures[i].mBoundTextures.clear();
146 inline void BindTexture(GLenum target, GLuint texture) override
148 // Record the bound textures for future checks
151 mBoundTextures.push_back(texture);
153 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
155 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
159 std::stringstream out;
160 out << target << ", " << texture;
162 TraceCallStack::NamedParams namedParams;
163 namedParams["target"] << target;
164 namedParams["texture"] << texture;
166 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
169 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
171 mLastBlendColor.r = red;
172 mLastBlendColor.g = green;
173 mLastBlendColor.b = blue;
174 mLastBlendColor.a = alpha;
177 inline const Vector4& GetLastBlendColor() const
179 return mLastBlendColor;
182 inline void BlendEquation(GLenum mode) override
184 mLastBlendEquationRgb = mode;
185 mLastBlendEquationAlpha = mode;
188 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
190 mLastBlendEquationRgb = modeRgb;
191 mLastBlendEquationAlpha = modeAlpha;
194 inline GLenum GetLastBlendEquationRgb() const
196 return mLastBlendEquationRgb;
199 inline GLenum GetLastBlendEquationAlpha() const
201 return mLastBlendEquationAlpha;
204 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
206 mLastBlendFuncSrcRgb = sfactor;
207 mLastBlendFuncDstRgb = dfactor;
208 mLastBlendFuncSrcAlpha = sfactor;
209 mLastBlendFuncDstAlpha = dfactor;
212 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
214 mLastBlendFuncSrcRgb = srcRGB;
215 mLastBlendFuncDstRgb = dstRGB;
216 mLastBlendFuncSrcAlpha = srcAlpha;
217 mLastBlendFuncDstAlpha = dstAlpha;
220 inline GLenum GetLastBlendFuncSrcRgb() const
222 return mLastBlendFuncSrcRgb;
225 inline GLenum GetLastBlendFuncDstRgb() const
227 return mLastBlendFuncDstRgb;
230 inline GLenum GetLastBlendFuncSrcAlpha() const
232 return mLastBlendFuncSrcAlpha;
235 inline GLenum GetLastBlendFuncDstAlpha() const
237 return mLastBlendFuncDstAlpha;
240 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
242 std::ostringstream o;
243 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
244 TraceCallStack::NamedParams namedParams;
245 namedParams["target"] << std::hex << target;
246 namedParams["size"] << size;
247 namedParams["usage"] << usage;
249 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
251 mBufferDataCalls.push_back(size);
254 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
256 std::ostringstream o;
257 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
258 TraceCallStack::NamedParams namedParams;
259 namedParams["target"] << std::hex << target;
260 namedParams["offset"] << offset;
261 namedParams["size"] << size;
262 mBufferTrace.PushCall("BufferSubData", o.str());
264 mBufferSubDataCalls.push_back(size);
267 inline GLenum CheckFramebufferStatus(GLenum target) override
269 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
270 //Framebuffer texture have been called
271 if(mFramebufferStatus == 7)
273 return GL_FRAMEBUFFER_COMPLETE;
276 return mCheckFramebufferStatusResult;
279 inline GLuint CheckFramebufferColorAttachmentCount()
281 return mFramebufferColorAttachmentCount;
284 inline GLenum CheckFramebufferDepthAttachment()
286 return mFramebufferDepthAttached;
289 inline GLenum CheckFramebufferStencilAttachment()
291 return mFramebufferStencilAttached;
294 inline void Clear(GLbitfield mask) override
297 mLastClearBitMask = mask;
300 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
302 mLastClearColor.r = red;
303 mLastClearColor.g = green;
304 mLastClearColor.b = blue;
305 mLastClearColor.a = alpha;
308 inline const Vector4& GetLastClearColor() const
310 return mLastClearColor;
313 inline void ClearDepthf(GLclampf depth) override
317 inline void ClearStencil(GLint s) override
319 std::stringstream out;
322 TraceCallStack::NamedParams namedParams;
323 namedParams["s"] << s;
325 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
328 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
330 mColorMaskParams.red = red;
331 mColorMaskParams.green = green;
332 mColorMaskParams.blue = blue;
333 mColorMaskParams.alpha = alpha;
336 inline void CompileShader(GLuint shader) override
338 std::stringstream out;
340 TraceCallStack::NamedParams namedParams;
341 namedParams["shader"] << shader;
343 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
346 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
348 std::stringstream out;
349 out << target << ", " << level << ", " << width << ", " << height;
351 TraceCallStack::NamedParams namedParams;
352 namedParams["target"] << std::hex << target;
353 namedParams["level"] << level;
354 namedParams["internalformat"] << internalformat;
355 namedParams["width"] << width;
356 namedParams["height"] << height;
357 namedParams["border"] << border;
358 namedParams["size"] << imageSize;
360 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
363 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
365 std::stringstream out;
366 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
368 TraceCallStack::NamedParams namedParams;
369 namedParams["target"] << std::hex << target;
370 namedParams["level"] << level;
371 namedParams["xoffset"] << xoffset;
372 namedParams["yoffset"] << yoffset;
373 namedParams["width"] << width;
374 namedParams["height"] << height;
375 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
378 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
382 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
386 inline GLuint CreateProgram(void) override
388 mShaderTrace.PushCall("CreateProgram", "");
390 ++mLastProgramIdUsed;
391 mUniforms[mLastProgramIdUsed] = UniformIDMap();
392 return mLastProgramIdUsed;
395 inline GLuint CreateShader(GLenum type) override
397 std::stringstream out;
400 TraceCallStack::NamedParams namedParams;
401 namedParams["type"] << std::hex << type;
402 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
404 return ++mLastShaderIdUsed;
407 inline void CullFace(GLenum mode) override
409 std::stringstream out;
410 out << std::hex << mode;
412 TraceCallStack::NamedParams namedParams;
413 namedParams["mode"] << std::hex << mode;
415 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
418 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
422 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
426 inline void DeleteProgram(GLuint program) override
428 std::stringstream out;
431 TraceCallStack::NamedParams namedParams;
432 namedParams["program"] << program;
434 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
437 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
441 inline void DeleteShader(GLuint shader) override
443 std::stringstream out;
446 TraceCallStack::NamedParams namedParams;
447 namedParams["shader"] << shader;
449 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
452 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
454 std::stringstream out;
455 out << "n:" << n << " textures[";
457 TraceCallStack::NamedParams namedParams;
459 for(GLsizei i = 0; i < n; i++)
461 out << (i > 0 ? ", " : "") << textures[i];
462 std::stringstream paramName;
463 paramName << "texture[" << i << "]";
464 namedParams[paramName.str()] << textures[i];
465 mDeletedTextureIds.push_back(textures[i]);
466 mNumGeneratedTextures--;
470 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
473 inline bool CheckNoTexturesDeleted()
475 return mDeletedTextureIds.size() == 0;
478 inline bool CheckTextureDeleted(GLuint textureId)
482 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
484 if(*iter == textureId)
493 inline void ClearDeletedTextures()
495 mDeletedTextureIds.clear();
498 inline void DepthFunc(GLenum func) override
500 std::stringstream out;
501 out << std::hex << func;
503 TraceCallStack::NamedParams namedParams;
504 namedParams["func"] << std::hex << func;
506 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
509 inline void DepthMask(GLboolean flag) override
511 mLastDepthMask = flag;
514 inline bool GetLastDepthMask() const
516 return mLastDepthMask;
519 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
523 inline void DetachShader(GLuint program, GLuint shader) override
525 std::stringstream out;
526 out << program << ", " << shader;
527 TraceCallStack::NamedParams namedParams;
528 namedParams["program"] << program;
529 namedParams["shader"] << shader;
530 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
533 inline void Disable(GLenum cap) override
535 std::stringstream out;
536 out << std::hex << cap;
537 TraceCallStack::NamedParams namedParams;
538 namedParams["cap"] << std::hex << cap;
539 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
542 inline void DisableVertexAttribArray(GLuint index) override
544 std::stringstream out;
546 TraceCallStack::NamedParams namedParams;
547 namedParams["index"] << index;
548 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
549 SetVertexAttribArray(index, false);
552 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
554 std::stringstream out;
555 out << mode << ", " << first << ", " << count;
556 TraceCallStack::NamedParams namedParams;
557 namedParams["mode"] << std::hex << mode;
558 namedParams["first"] << first;
559 namedParams["count"] << count;
560 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
563 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
565 std::stringstream out;
566 out << mode << ", " << count << ", " << type << ", indices";
568 TraceCallStack::NamedParams namedParams;
569 namedParams["mode"] << std::hex << mode;
570 namedParams["count"] << count;
571 namedParams["type"] << type;
572 // Skip void pointers - are they of any use?
573 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
576 inline void Enable(GLenum cap) override
578 std::stringstream out;
579 out << std::hex << cap;
580 TraceCallStack::NamedParams namedParams;
581 namedParams["cap"] << std::hex << cap;
582 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
585 inline void EnableVertexAttribArray(GLuint index) override
587 std::stringstream out;
589 TraceCallStack::NamedParams namedParams;
590 namedParams["index"] << index;
591 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
592 SetVertexAttribArray(index, true);
595 inline void Finish(void) override
599 inline void Flush(void) override
603 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
605 if(attachment == GL_DEPTH_ATTACHMENT)
607 mFramebufferDepthAttached = true;
609 else if(attachment == GL_STENCIL_ATTACHMENT)
611 mFramebufferStencilAttached = true;
615 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
618 mFramebufferStatus |= 4;
620 //We check 4 attachment colors
621 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
623 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
624 if((mFrameBufferColorStatus & mask) == 0)
626 mFrameBufferColorStatus |= mask;
627 ++mFramebufferColorAttachmentCount;
632 inline void FrontFace(GLenum mode) override
637 inline void GenBuffers(GLsizei n, GLuint* buffers) override
639 // avoids an assert in GpuBuffers
642 std::ostringstream o;
644 TraceCallStack::NamedParams namedParams;
645 namedParams["n"] << o.str();
646 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
649 inline void GenerateMipmap(GLenum target) override
651 std::stringstream out;
653 TraceCallStack::NamedParams namedParams;
654 namedParams["target"] << std::hex << target;
656 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
659 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
661 for(int i = 0; i < n; i++)
663 framebuffers[i] = i + 1;
666 //Add 001 bit, this function needs to be called the first one in the chain
667 mFramebufferStatus = 1;
670 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
672 for(int i = 0; i < n; i++)
674 renderbuffers[i] = i + 1;
679 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
680 * @param[in] ids A vector containing the next IDs to be generated
682 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
684 mNextTextureIds = ids;
687 inline const std::vector<GLuint>& GetNextTextureIds()
689 return mNextTextureIds;
692 inline void GenTextures(GLsizei count, GLuint* textures) override
694 for(int i = 0; i < count; ++i)
696 if(!mNextTextureIds.empty())
698 *(textures + i) = mNextTextureIds[0];
699 mNextTextureIds.erase(mNextTextureIds.begin());
703 *(textures + i) = ++mLastAutoTextureIdUsed;
705 mNumGeneratedTextures++;
708 TraceCallStack::NamedParams namedParams;
709 namedParams["count"] << count;
711 std::stringstream out;
712 for(int i = 0; i < count; i++)
719 std::ostringstream oss;
720 oss << "indices[" << i << "]";
721 namedParams[oss.str()] << textures[i];
724 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
727 inline GLuint GetLastGenTextureId()
729 return mLastAutoTextureIdUsed;
732 inline GLuint GetNumGeneratedTextures()
734 return mNumGeneratedTextures;
737 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
741 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
746 *length = snprintf(name, bufsize, "sTexture");
747 *type = GL_SAMPLER_2D;
751 *length = snprintf(name, bufsize, "sEffect");
752 *type = GL_SAMPLER_2D;
756 *length = snprintf(name, bufsize, "sGloss");
757 *type = GL_SAMPLER_2D;
765 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
769 inline int GetAttribLocation(GLuint program, const char* name) override
771 std::string check(name);
772 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
773 if(iter == mAttribLocs.end())
775 return iter - mAttribLocs.begin();
778 inline void GetBooleanv(GLenum pname, GLboolean* params) override
782 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
786 inline GLenum GetError(void) override
788 return mGetErrorResult;
791 inline void GetFloatv(GLenum pname, GLfloat* params) override
795 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
799 inline void GetIntegerv(GLenum pname, GLint* params) override
803 case GL_MAX_TEXTURE_SIZE:
806 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
809 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
810 *params = mNumBinaryFormats;
812 case GL_PROGRAM_BINARY_FORMATS_OES:
813 *params = mBinaryFormats;
818 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
823 *params = mLinkStatus;
825 case GL_PROGRAM_BINARY_LENGTH_OES:
826 *params = mProgramBinaryLength;
828 case GL_ACTIVE_UNIFORMS:
829 *params = mNumberOfActiveUniforms;
831 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
837 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
841 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
845 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
849 case GL_COMPILE_STATUS:
850 *params = mCompileStatus;
855 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
859 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
863 inline const GLubyte* GetString(GLenum name) override
865 return mGetStringResult;
868 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
872 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
876 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
880 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
884 inline GLint GetUniformLocation(GLuint program, const char* name) override
886 ProgramUniformMap::iterator it = mUniforms.find(program);
887 if(it == mUniforms.end())
889 // Not a valid program ID
890 mGetErrorResult = GL_INVALID_OPERATION;
894 UniformIDMap& uniformIDs = it->second;
895 UniformIDMap::iterator it2 = uniformIDs.find(name);
896 if(it2 == uniformIDs.end())
898 // Uniform not found, so add it...
899 uniformIDs[name] = ++mLastUniformIdUsed;
900 return mLastUniformIdUsed;
906 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
910 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
914 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
918 inline void Hint(GLenum target, GLenum mode) override
922 inline GLboolean IsBuffer(GLuint buffer) override
924 return mIsBufferResult;
927 inline GLboolean IsEnabled(GLenum cap) override
929 return mIsEnabledResult;
932 inline GLboolean IsFramebuffer(GLuint framebuffer) override
934 return mIsFramebufferResult;
937 inline GLboolean IsProgram(GLuint program) override
939 return mIsProgramResult;
942 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
944 return mIsRenderbufferResult;
947 inline GLboolean IsShader(GLuint shader) override
949 return mIsShaderResult;
952 inline GLboolean IsTexture(GLuint texture) override
954 return mIsTextureResult;
957 inline void LineWidth(GLfloat width) override
961 inline void LinkProgram(GLuint program) override
963 std::stringstream out;
966 TraceCallStack::NamedParams namedParams;
967 namedParams["program"] << program;
968 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
970 mNumberOfActiveUniforms = 3;
971 GetUniformLocation(program, "sTexture");
972 GetUniformLocation(program, "sEffect");
973 GetUniformLocation(program, "sGloss");
976 inline void PixelStorei(GLenum pname, GLint param) override
980 inline void PolygonOffset(GLfloat factor, GLfloat units) override
984 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
988 inline void ReleaseShaderCompiler(void) override
992 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
996 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1000 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1002 mScissorParams.x = x;
1003 mScissorParams.y = y;
1004 mScissorParams.width = width;
1005 mScissorParams.height = height;
1007 std::stringstream out;
1008 out << x << ", " << y << ", " << width << ", " << height;
1009 TraceCallStack::NamedParams namedParams;
1010 namedParams["x"] << x;
1011 namedParams["y"] << y;
1012 namedParams["width"] << width;
1013 namedParams["height"] << height;
1014 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1017 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1021 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1023 std::string stringBuilder;
1024 for(int i = 0; i < count; ++i)
1026 stringBuilder += string[i];
1028 mShaderSources[shader] = stringBuilder;
1029 mLastShaderCompiled = shader;
1032 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1034 const std::string shaderSource = mShaderSources[shader];
1035 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1036 if(shaderSourceLength < bufsize)
1038 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1039 *length = shaderSourceLength;
1043 *length = bufsize - 1;
1044 strncpy(source, shaderSource.c_str(), *length);
1045 source[*length] = 0x0;
1049 inline std::string GetShaderSource(GLuint shader)
1051 return mShaderSources[shader];
1054 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1056 std::stringstream out;
1057 out << func << ", " << ref << ", " << mask;
1059 TraceCallStack::NamedParams namedParams;
1060 namedParams["func"] << std::hex << func;
1061 namedParams["ref"] << ref;
1062 namedParams["mask"] << mask;
1064 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1067 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1069 std::stringstream out;
1070 out << face << ", " << func << ", " << ref << ", " << mask;
1072 TraceCallStack::NamedParams namedParams;
1073 namedParams["face"] << std::hex << face;
1074 namedParams["func"] << std::hex << func;
1075 namedParams["ref"] << ref;
1076 namedParams["mask"] << mask;
1078 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1081 inline void StencilMask(GLuint mask) override
1083 std::stringstream out;
1086 TraceCallStack::NamedParams namedParams;
1087 namedParams["mask"] << mask;
1089 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1092 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1094 std::stringstream out;
1095 out << face << ", " << mask;
1097 TraceCallStack::NamedParams namedParams;
1098 namedParams["face"] << std::hex << face;
1099 namedParams["mask"] << mask;
1101 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1104 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1106 std::stringstream out;
1107 out << fail << ", " << zfail << ", " << zpass;
1109 TraceCallStack::NamedParams namedParams;
1110 namedParams["fail"] << std::hex << fail;
1111 namedParams["zfail"] << std::hex << zfail;
1112 namedParams["zpass"] << std::hex << zpass;
1114 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1117 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1119 std::stringstream out;
1120 out << face << ", " << fail << ", " << zfail << "," << zpass;
1122 TraceCallStack::NamedParams namedParams;
1123 namedParams["face"] << std::hex << face;
1124 namedParams["fail"] << std::hex << fail;
1125 namedParams["zfail"] << std::hex << zfail;
1126 namedParams["zpass"] << std::hex << zpass;
1128 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1131 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1133 std::stringstream out;
1134 out << target << ", " << level << ", " << width << ", " << height;
1136 TraceCallStack::NamedParams namedParams;
1137 namedParams["target"] << std::hex << target;
1138 namedParams["level"] << level;
1139 namedParams["internalformat"] << internalformat;
1140 namedParams["width"] << width;
1141 namedParams["height"] << height;
1142 namedParams["border"] << border;
1143 namedParams["format"] << std::hex << format;
1144 namedParams["type"] << std::hex << type;
1146 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1149 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1151 std::stringstream out;
1152 out << target << ", " << pname << ", " << param;
1154 TraceCallStack::NamedParams namedParams;
1155 namedParams["target"] << std::hex << target;
1156 namedParams["pname"] << std::hex << pname;
1157 namedParams["param"] << param;
1159 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1162 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1164 std::stringstream out;
1165 out << target << ", " << pname << ", " << params[0];
1167 TraceCallStack::NamedParams namedParams;
1168 namedParams["target"] << std::hex << target;
1169 namedParams["pname"] << std::hex << pname;
1170 namedParams["params[0]"] << params[0];
1172 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1175 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1177 std::stringstream out;
1178 out << std::hex << target << ", " << pname << ", " << param;
1179 std::string params = out.str();
1182 out << std::hex << target;
1183 TraceCallStack::NamedParams namedParams;
1184 namedParams["target"] << out.str();
1186 out << std::hex << pname;
1187 namedParams["pname"] << out.str();
1189 out << std::hex << param;
1190 namedParams["param"] << out.str();
1191 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1194 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1196 std::stringstream out;
1197 out << target << ", " << pname << ", " << params[0];
1198 TraceCallStack::NamedParams namedParams;
1199 namedParams["target"] << std::hex << target;
1200 namedParams["pname"] << std::hex << pname;
1201 namedParams["params[0]"] << params[0];
1202 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1205 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1207 std::stringstream out;
1208 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1210 TraceCallStack::NamedParams namedParams;
1211 namedParams["target"] << std::hex << target;
1212 namedParams["level"] << level;
1213 namedParams["xoffset"] << xoffset;
1214 namedParams["yoffset"] << yoffset;
1215 namedParams["width"] << width;
1216 namedParams["height"] << height;
1217 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1220 inline void Uniform1f(GLint location, GLfloat value) override
1222 std::string params = std::to_string(value);
1223 AddUniformCallToTraceStack(location, params);
1225 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1227 mGetErrorResult = GL_INVALID_OPERATION;
1231 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1234 for(int i = 0; i < count; ++i)
1236 params = params + std::to_string(v[i]) + ",";
1239 AddUniformCallToTraceStack(location, params);
1241 for(int i = 0; i < count; ++i)
1243 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1245 mGetErrorResult = GL_INVALID_OPERATION;
1251 inline void Uniform1i(GLint location, GLint x) override
1253 std::string params = std::to_string(x);
1255 AddUniformCallToTraceStack(location, params);
1257 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1259 mGetErrorResult = GL_INVALID_OPERATION;
1263 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1265 std::ostringstream out;
1266 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1267 AddUniformCallToTraceStack(location, out.str());
1269 for(int i = 0; i < count; ++i)
1271 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1275 mGetErrorResult = GL_INVALID_OPERATION;
1281 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1283 std::string params = std::to_string(x) + "," + std::to_string(y);
1284 AddUniformCallToTraceStack(location, params);
1286 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1290 mGetErrorResult = GL_INVALID_OPERATION;
1294 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1296 std::ostringstream out;
1297 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1298 AddUniformCallToTraceStack(location, out.str());
1300 for(int i = 0; i < count; ++i)
1302 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1304 Vector2(v[2 * i], v[2 * i + 1])))
1306 mGetErrorResult = GL_INVALID_OPERATION;
1312 inline void Uniform2i(GLint location, GLint x, GLint y) override
1314 std::string params = std::to_string(x) + "," + std::to_string(y);
1315 AddUniformCallToTraceStack(location, params);
1318 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1320 std::ostringstream out;
1321 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1322 AddUniformCallToTraceStack(location, out.str());
1325 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1327 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1328 AddUniformCallToTraceStack(location, params);
1330 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1334 mGetErrorResult = GL_INVALID_OPERATION;
1338 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1340 std::ostringstream out;
1341 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1342 AddUniformCallToTraceStack(location, out.str());
1344 for(int i = 0; i < count; ++i)
1346 if(!mProgramUniforms3f.SetUniformValue(
1349 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1351 mGetErrorResult = GL_INVALID_OPERATION;
1357 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1359 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1360 AddUniformCallToTraceStack(location, params);
1363 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1365 std::ostringstream out;
1366 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1367 AddUniformCallToTraceStack(location, out.str());
1370 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1372 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1373 AddUniformCallToTraceStack(location, params);
1375 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1377 Vector4(x, y, z, w)))
1379 mGetErrorResult = GL_INVALID_OPERATION;
1383 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1385 std::ostringstream out;
1386 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1387 AddUniformCallToTraceStack(location, out.str());
1389 for(int i = 0; i < count; ++i)
1391 if(!mProgramUniforms4f.SetUniformValue(
1394 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1396 mGetErrorResult = GL_INVALID_OPERATION;
1402 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint 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);
1408 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1410 std::ostringstream out;
1411 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1412 AddUniformCallToTraceStack(location, out.str());
1415 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1417 std::ostringstream out;
1418 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1419 AddUniformCallToTraceStack(location, out.str());
1422 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1424 std::ostringstream out;
1425 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1426 AddUniformCallToTraceStack(location, out.str());
1428 for(int i = 0; i < count; ++i)
1430 if(!mProgramUniformsMat3.SetUniformValue(
1433 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1435 mGetErrorResult = GL_INVALID_OPERATION;
1441 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1443 std::ostringstream out;
1444 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1445 AddUniformCallToTraceStack(location, out.str());
1447 for(int i = 0; i < count; ++i)
1449 if(!mProgramUniformsMat4.SetUniformValue(
1454 mGetErrorResult = GL_INVALID_OPERATION;
1460 inline void UseProgram(GLuint program) override
1462 mCurrentProgram = program;
1465 inline void ValidateProgram(GLuint program) override
1469 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1473 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1477 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1481 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1485 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1489 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1493 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1497 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1501 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1503 TraceCallStack::NamedParams namedParams;
1504 namedParams["index"] << index;
1505 namedParams["size"] << size;
1506 namedParams["type"] << std::hex << type;
1507 namedParams["normalized"] << (normalized ? "T" : "F");
1508 namedParams["stride"] << stride;
1509 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1511 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1514 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1516 std::string commaString(", ");
1517 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1519 mViewportTrace.PushCall("Viewport", params);
1524 inline void ReadBuffer(GLenum mode) override
1528 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1532 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
1536 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
1540 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1544 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1548 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
1552 inline void GenQueries(GLsizei n, GLuint* ids) override
1556 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1560 inline GLboolean IsQuery(GLuint id) override
1565 inline void BeginQuery(GLenum target, GLuint id) override
1569 inline void EndQuery(GLenum target) override
1573 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1577 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1581 inline GLboolean UnmapBuffer(GLenum target) override
1586 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1590 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1594 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1598 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1602 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1606 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1610 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1614 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1618 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1622 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1626 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1630 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1635 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1639 inline void BindVertexArray(GLuint array) override
1643 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1647 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1651 inline GLboolean IsVertexArray(GLuint array) override
1656 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1660 inline void BeginTransformFeedback(GLenum primitiveMode) override
1664 inline void EndTransformFeedback(void) override
1668 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1672 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1676 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1680 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1684 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1688 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1692 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1696 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1700 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1704 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1708 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1712 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1716 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1721 inline void Uniform1ui(GLint location, GLuint v0) override
1725 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1729 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1733 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1737 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1741 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1745 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1749 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1753 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1757 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1761 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1765 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1769 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1774 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1778 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1782 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1786 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1788 return GL_INVALID_INDEX;
1791 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1795 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1799 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1803 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1807 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1811 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1816 inline GLboolean IsSync(GLsync sync) override
1821 inline void DeleteSync(GLsync sync) override
1825 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1830 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1834 inline void GetInteger64v(GLenum pname, GLint64* params) override
1838 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1842 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1846 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1850 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1854 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1858 inline GLboolean IsSampler(GLuint sampler) override
1863 inline void BindSampler(GLuint unit, GLuint sampler) override
1867 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1871 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1875 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1879 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1883 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1887 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1891 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1895 inline void BindTransformFeedback(GLenum target, GLuint id) override
1899 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1903 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1907 inline GLboolean IsTransformFeedback(GLuint id) override
1912 inline void PauseTransformFeedback(void) override
1916 inline void ResumeTransformFeedback(void) override
1920 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1922 mGetProgramBinaryCalled = true;
1925 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1929 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1933 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1937 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1941 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1945 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1949 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1953 inline void BlendBarrier(void)
1958 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1960 std::string name = "<not found>";
1961 bool matched = false;
1963 UniformIDMap& map = mUniforms[mCurrentProgram];
1964 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1966 if(it->second == location)
1976 mSetUniformTrace.PushCall(name, value);
1980 public: // TEST FUNCTIONS
1981 inline void SetCompileStatus(GLuint value)
1983 mCompileStatus = value;
1985 inline void SetLinkStatus(GLuint value)
1987 mLinkStatus = value;
1989 inline void SetAttribLocations(std::vector<std::string> locs)
1993 inline void SetGetErrorResult(GLenum result)
1995 mGetErrorResult = result;
1997 inline void SetGetStringResult(GLubyte* result)
1999 mGetStringResult = result;
2001 inline void SetIsBufferResult(GLboolean result)
2003 mIsBufferResult = result;
2005 inline void SetIsEnabledResult(GLboolean result)
2007 mIsEnabledResult = result;
2009 inline void SetIsFramebufferResult(GLboolean result)
2011 mIsFramebufferResult = result;
2013 inline void SetIsProgramResult(GLboolean result)
2015 mIsProgramResult = result;
2017 inline void SetIsRenderbufferResult(GLboolean result)
2019 mIsRenderbufferResult = result;
2021 inline void SetIsShaderResult(GLboolean result)
2023 mIsShaderResult = result;
2025 inline void SetIsTextureResult(GLboolean result)
2027 mIsTextureResult = result;
2029 inline void SetCheckFramebufferStatusResult(GLenum result)
2031 mCheckFramebufferStatusResult = result;
2033 inline void SetNumBinaryFormats(GLint numFormats)
2035 mNumBinaryFormats = numFormats;
2037 inline void SetBinaryFormats(GLint binaryFormats)
2039 mBinaryFormats = binaryFormats;
2041 inline void SetProgramBinaryLength(GLint length)
2043 mProgramBinaryLength = length;
2046 inline bool GetVertexAttribArrayState(GLuint index)
2048 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2053 return mVertexAttribArrayState[index];
2055 inline void ClearVertexAttribArrayChanged()
2057 mVertexAttribArrayChanged = false;
2059 inline bool GetVertexAttribArrayChanged()
2061 return mVertexAttribArrayChanged;
2064 //Methods for CullFace verification
2065 inline void EnableCullFaceCallTrace(bool enable)
2067 mCullFaceTrace.Enable(enable);
2069 inline void ResetCullFaceCallStack()
2071 mCullFaceTrace.Reset();
2073 inline TraceCallStack& GetCullFaceTrace()
2075 return mCullFaceTrace;
2078 //Methods for Enable/Disable call verification
2079 inline void EnableEnableDisableCallTrace(bool enable)
2081 mEnableDisableTrace.Enable(enable);
2083 inline void ResetEnableDisableCallStack()
2085 mEnableDisableTrace.Reset();
2087 inline TraceCallStack& GetEnableDisableTrace()
2089 return mEnableDisableTrace;
2092 //Methods for Shader verification
2093 inline void EnableShaderCallTrace(bool enable)
2095 mShaderTrace.Enable(enable);
2097 inline void ResetShaderCallStack()
2099 mShaderTrace.Reset();
2101 inline TraceCallStack& GetShaderTrace()
2103 return mShaderTrace;
2106 //Methods for Texture verification
2107 inline void EnableTextureCallTrace(bool enable)
2109 mTextureTrace.Enable(enable);
2111 inline void ResetTextureCallStack()
2113 mTextureTrace.Reset();
2115 inline TraceCallStack& GetTextureTrace()
2117 return mTextureTrace;
2120 //Methods for Texture verification
2121 inline void EnableTexParameterCallTrace(bool enable)
2123 mTexParameterTrace.Enable(enable);
2125 inline void ResetTexParameterCallStack()
2127 mTexParameterTrace.Reset();
2129 inline TraceCallStack& GetTexParameterTrace()
2131 return mTexParameterTrace;
2134 //Methods for Draw verification
2135 inline void EnableDrawCallTrace(bool enable)
2137 mDrawTrace.Enable(enable);
2139 inline void ResetDrawCallStack()
2143 inline TraceCallStack& GetDrawTrace()
2148 //Methods for Depth function verification
2149 inline void EnableDepthFunctionCallTrace(bool enable)
2151 mDepthFunctionTrace.Enable(enable);
2153 inline void ResetDepthFunctionCallStack()
2155 mDepthFunctionTrace.Reset();
2157 inline TraceCallStack& GetDepthFunctionTrace()
2159 return mDepthFunctionTrace;
2162 //Methods for Stencil function verification
2163 inline void EnableStencilFunctionCallTrace(bool enable)
2165 mStencilFunctionTrace.Enable(enable);
2167 inline void ResetStencilFunctionCallStack()
2169 mStencilFunctionTrace.Reset();
2171 inline TraceCallStack& GetStencilFunctionTrace()
2173 return mStencilFunctionTrace;
2176 //Methods for Scissor verification
2177 inline void EnableScissorCallTrace(bool enable)
2179 mScissorTrace.Enable(enable);
2181 inline void ResetScissorCallStack()
2183 mScissorTrace.Reset();
2185 inline TraceCallStack& GetScissorTrace()
2187 return mScissorTrace;
2190 //Methods for Uniform function verification
2191 inline void EnableSetUniformCallTrace(bool enable)
2193 mSetUniformTrace.Enable(enable);
2195 inline void ResetSetUniformCallStack()
2197 mSetUniformTrace.Reset();
2199 inline TraceCallStack& GetSetUniformTrace()
2201 return mSetUniformTrace;
2204 //Methods for Viewport verification
2205 inline void EnableViewportCallTrace(bool enable)
2207 mViewportTrace.Enable(enable);
2209 inline void ResetViewportCallStack()
2211 mViewportTrace.Reset();
2213 inline TraceCallStack& GetViewportTrace()
2215 return mViewportTrace;
2217 inline TraceCallStack& GetBufferTrace()
2219 return mBufferTrace;
2222 template<typename T>
2223 inline bool GetUniformValue(const char* name, T& value) const
2225 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2226 program_it != mUniforms.end();
2229 const UniformIDMap& uniformIDs = program_it->second;
2231 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2232 if(uniform_it != uniformIDs.end())
2234 // found one matching uniform name, lets check the value...
2235 GLuint programId = program_it->first;
2236 GLint uniformId = uniform_it->second;
2238 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2239 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2245 template<typename T>
2246 inline bool CheckUniformValue(const char* name, const T& value) const
2248 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2249 program_it != mUniforms.end();
2252 const UniformIDMap& uniformIDs = program_it->second;
2254 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2255 if(uniform_it != uniformIDs.end())
2257 // found one matching uniform name, lets check the value...
2258 GLuint programId = program_it->first;
2259 GLint uniformId = uniform_it->second;
2261 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2262 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2264 // the value matches
2270 fprintf(stderr, "Not found, printing possible values:\n");
2271 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2272 program_it != mUniforms.end();
2275 const UniformIDMap& uniformIDs = program_it->second;
2277 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2278 if(uniform_it != uniformIDs.end())
2280 // found one matching uniform name, lets check the value...
2281 GLuint programId = program_it->first;
2282 GLint uniformId = uniform_it->second;
2284 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2286 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2288 std::stringstream out;
2289 out << uniform_it->first << ": " << origValue;
2290 fprintf(stderr, "%s\n", out.str().c_str());
2297 template<typename T>
2298 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2300 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2301 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2304 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2306 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2307 program_it != mUniforms.end();
2310 const UniformIDMap& uniformIDs = program_it->second;
2312 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2313 if(uniform_it != uniformIDs.end())
2315 programId = program_it->first;
2316 uniformId = uniform_it->second;
2323 inline GLuint GetLastShaderCompiled() const
2325 return mLastShaderCompiled;
2328 inline GLuint GetLastProgramCreated() const
2330 return mLastProgramIdUsed;
2333 inline GLbitfield GetLastClearMask() const
2335 return mLastClearBitMask;
2340 ATTRIB_UNKNOWN = -1,
2345 ATTRIB_BONE_WEIGHTS,
2346 ATTRIB_BONE_INDICES,
2350 struct ScissorParams
2366 // Methods to check scissor tests
2367 inline const ScissorParams& GetScissorParams() const
2369 return mScissorParams;
2372 struct ColorMaskParams
2388 inline bool GetProgramBinaryCalled() const
2390 return mGetProgramBinaryCalled;
2393 inline unsigned int GetClearCountCalled() const
2398 inline const ColorMaskParams& GetColorMaskParams() const
2400 return mColorMaskParams;
2403 typedef std::vector<size_t> BufferDataCalls;
2404 inline const BufferDataCalls& GetBufferDataCalls() const
2406 return mBufferDataCalls;
2408 inline void ResetBufferDataCalls()
2410 mBufferDataCalls.clear();
2413 typedef std::vector<size_t> BufferSubDataCalls;
2414 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2416 return mBufferSubDataCalls;
2418 inline void ResetBufferSubDataCalls()
2420 mBufferSubDataCalls.clear();
2424 GLuint mCurrentProgram;
2425 GLuint mCompileStatus;
2426 BufferDataCalls mBufferDataCalls;
2427 BufferSubDataCalls mBufferSubDataCalls;
2429 GLint mNumberOfActiveUniforms;
2430 GLenum mGetErrorResult;
2431 GLubyte* mGetStringResult;
2432 GLboolean mIsBufferResult;
2433 GLboolean mIsEnabledResult;
2434 GLboolean mIsFramebufferResult;
2435 GLboolean mIsProgramResult;
2436 GLboolean mIsRenderbufferResult;
2437 GLboolean mIsShaderResult;
2438 GLboolean mIsTextureResult;
2439 GLenum mActiveTextureUnit;
2440 GLenum mCheckFramebufferStatusResult;
2441 GLint mFramebufferStatus;
2442 GLenum mFramebufferDepthAttached;
2443 GLenum mFramebufferStencilAttached;
2444 GLuint mFramebufferColorAttachmentCount;
2445 GLuint mFrameBufferColorStatus;
2446 GLint mNumBinaryFormats;
2447 GLint mBinaryFormats;
2448 GLint mProgramBinaryLength;
2449 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2450 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2451 bool mGetProgramBinaryCalled;
2452 typedef std::map<GLuint, std::string> ShaderSourceMap;
2453 ShaderSourceMap mShaderSources;
2454 std::vector<std::string> mAttribLocs; // should be bound to shader
2455 GLuint mLastShaderCompiled;
2456 GLbitfield mLastClearBitMask;
2457 Vector4 mLastClearColor;
2458 unsigned int mClearCount;
2460 Vector4 mLastBlendColor;
2461 GLenum mLastBlendEquationRgb;
2462 GLenum mLastBlendEquationAlpha;
2463 GLenum mLastBlendFuncSrcRgb;
2464 GLenum mLastBlendFuncDstRgb;
2465 GLenum mLastBlendFuncSrcAlpha;
2466 GLenum mLastBlendFuncDstAlpha;
2468 GLboolean mLastDepthMask;
2470 // Data for manipulating the IDs returned by GenTextures
2471 GLuint mLastAutoTextureIdUsed;
2472 GLuint mNumGeneratedTextures;
2473 std::vector<GLuint> mNextTextureIds;
2474 std::vector<GLuint> mDeletedTextureIds;
2475 std::vector<GLuint> mBoundTextures;
2477 struct ActiveTextureType
2479 std::vector<GLuint> mBoundTextures;
2482 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2484 TraceCallStack mBufferTrace;
2485 TraceCallStack mCullFaceTrace;
2486 TraceCallStack mEnableDisableTrace;
2487 TraceCallStack mShaderTrace;
2488 TraceCallStack mTextureTrace;
2489 TraceCallStack mTexParameterTrace;
2490 TraceCallStack mDrawTrace;
2491 TraceCallStack mDepthFunctionTrace;
2492 TraceCallStack mStencilFunctionTrace;
2493 TraceCallStack mScissorTrace;
2494 TraceCallStack mSetUniformTrace;
2495 TraceCallStack mViewportTrace;
2497 // Shaders & Uniforms
2498 GLuint mLastShaderIdUsed;
2499 GLuint mLastProgramIdUsed{0u};
2500 GLuint mLastUniformIdUsed;
2501 typedef std::map<std::string, GLint> UniformIDMap;
2502 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2503 ProgramUniformMap mUniforms;
2505 template<typename T>
2506 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2509 typedef std::map<GLint, T> UniformValueMap;
2510 typedef std::map<GLuint, UniformValueMap> Map;
2512 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2519 typename Map::iterator it = Map::find(program);
2520 if(it == Map::end())
2522 // if its the first uniform for this program add it
2523 std::pair<typename Map::iterator, bool> result =
2524 Map::insert(typename Map::value_type(program, UniformValueMap()));
2528 UniformValueMap& uniforms = it->second;
2529 uniforms[uniform] = value;
2534 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2537 if(GetUniformValue(program, uniform, uniformValue))
2539 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2545 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2552 typename Map::const_iterator it = Map::find(program);
2553 if(it == Map::end())
2555 // Uniform values always initialised as 0
2560 const UniformValueMap& uniforms = it->second;
2561 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2562 if(it2 == uniforms.end())
2564 // Uniform values always initialised as 0
2568 value = it2->second;
2575 ProgramUniformValue<int> mProgramUniforms1i;
2576 ProgramUniformValue<float> mProgramUniforms1f;
2577 ProgramUniformValue<Vector2> mProgramUniforms2f;
2578 ProgramUniformValue<Vector3> mProgramUniforms3f;
2579 ProgramUniformValue<Vector4> mProgramUniforms4f;
2580 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2581 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2583 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2585 return mProgramUniforms1i;
2587 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2589 return mProgramUniforms1f;
2591 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2593 return mProgramUniforms2f;
2595 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2597 return mProgramUniforms3f;
2599 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2601 return mProgramUniforms4f;
2603 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2605 return mProgramUniformsMat4;
2607 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2609 return mProgramUniformsMat3;
2611 inline void SetVertexAttribArray(GLuint index, bool state)
2613 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2618 mVertexAttribArrayState[index] = state;
2619 mVertexAttribArrayChanged = true;
2622 ScissorParams mScissorParams;
2623 ColorMaskParams mColorMaskParams;
2627 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2633 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2639 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2641 return Vector2::ZERO;
2645 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2647 return Vector3::ZERO;
2651 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2653 return Vector4::ZERO;
2657 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2663 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2665 return Matrix3(Matrix());
2670 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2671 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2673 #endif // TEST_GL_ABSTRACTION_H