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 << std::hex << target << ", " << std::dec << texture;
162 TraceCallStack::NamedParams namedParams;
163 namedParams["target"] << std::hex << 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:
834 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
840 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
844 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
848 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
852 case GL_COMPILE_STATUS:
853 *params = mCompileStatus;
858 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
862 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
866 inline const GLubyte* GetString(GLenum name) override
868 return mGetStringResult;
871 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
875 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
879 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
883 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
887 inline GLint GetUniformLocation(GLuint program, const char* name) override
889 ProgramUniformMap::iterator it = mUniforms.find(program);
890 if(it == mUniforms.end())
892 // Not a valid program ID
893 mGetErrorResult = GL_INVALID_OPERATION;
897 UniformIDMap& uniformIDs = it->second;
898 UniformIDMap::iterator it2 = uniformIDs.find(name);
899 if(it2 == uniformIDs.end())
901 // Uniform not found, so add it...
902 uniformIDs[name] = ++mLastUniformIdUsed;
903 return mLastUniformIdUsed;
909 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
913 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
917 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
921 inline void Hint(GLenum target, GLenum mode) override
925 inline GLboolean IsBuffer(GLuint buffer) override
927 return mIsBufferResult;
930 inline GLboolean IsEnabled(GLenum cap) override
932 return mIsEnabledResult;
935 inline GLboolean IsFramebuffer(GLuint framebuffer) override
937 return mIsFramebufferResult;
940 inline GLboolean IsProgram(GLuint program) override
942 return mIsProgramResult;
945 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
947 return mIsRenderbufferResult;
950 inline GLboolean IsShader(GLuint shader) override
952 return mIsShaderResult;
955 inline GLboolean IsTexture(GLuint texture) override
957 return mIsTextureResult;
960 inline void LineWidth(GLfloat width) override
964 inline void LinkProgram(GLuint program) override
966 std::stringstream out;
969 TraceCallStack::NamedParams namedParams;
970 namedParams["program"] << program;
971 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
973 mNumberOfActiveUniforms = 3;
974 GetUniformLocation(program, "sTexture");
975 GetUniformLocation(program, "sEffect");
976 GetUniformLocation(program, "sGloss");
979 inline void PixelStorei(GLenum pname, GLint param) override
983 inline void PolygonOffset(GLfloat factor, GLfloat units) override
987 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
991 inline void ReleaseShaderCompiler(void) override
995 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
999 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1003 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1005 mScissorParams.x = x;
1006 mScissorParams.y = y;
1007 mScissorParams.width = width;
1008 mScissorParams.height = height;
1010 std::stringstream out;
1011 out << x << ", " << y << ", " << width << ", " << height;
1012 TraceCallStack::NamedParams namedParams;
1013 namedParams["x"] << x;
1014 namedParams["y"] << y;
1015 namedParams["width"] << width;
1016 namedParams["height"] << height;
1017 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1020 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1024 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1026 std::string stringBuilder;
1027 for(int i = 0; i < count; ++i)
1029 stringBuilder += string[i];
1031 mShaderSources[shader] = stringBuilder;
1032 mLastShaderCompiled = shader;
1035 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1037 const std::string shaderSource = mShaderSources[shader];
1038 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1039 if(shaderSourceLength < bufsize)
1041 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1042 *length = shaderSourceLength;
1046 *length = bufsize - 1;
1047 strncpy(source, shaderSource.c_str(), *length);
1048 source[*length] = 0x0;
1052 inline std::string GetShaderSource(GLuint shader)
1054 return mShaderSources[shader];
1057 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1059 std::stringstream out;
1060 out << func << ", " << ref << ", " << mask;
1062 TraceCallStack::NamedParams namedParams;
1063 namedParams["func"] << std::hex << func;
1064 namedParams["ref"] << ref;
1065 namedParams["mask"] << mask;
1067 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1070 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1072 std::stringstream out;
1073 out << face << ", " << func << ", " << ref << ", " << mask;
1075 TraceCallStack::NamedParams namedParams;
1076 namedParams["face"] << std::hex << face;
1077 namedParams["func"] << std::hex << func;
1078 namedParams["ref"] << ref;
1079 namedParams["mask"] << mask;
1081 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1084 inline void StencilMask(GLuint mask) override
1086 std::stringstream out;
1089 TraceCallStack::NamedParams namedParams;
1090 namedParams["mask"] << mask;
1092 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1095 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1097 std::stringstream out;
1098 out << face << ", " << mask;
1100 TraceCallStack::NamedParams namedParams;
1101 namedParams["face"] << std::hex << face;
1102 namedParams["mask"] << mask;
1104 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1107 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1109 std::stringstream out;
1110 out << fail << ", " << zfail << ", " << zpass;
1112 TraceCallStack::NamedParams namedParams;
1113 namedParams["fail"] << std::hex << fail;
1114 namedParams["zfail"] << std::hex << zfail;
1115 namedParams["zpass"] << std::hex << zpass;
1117 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1120 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1122 std::stringstream out;
1123 out << face << ", " << fail << ", " << zfail << "," << zpass;
1125 TraceCallStack::NamedParams namedParams;
1126 namedParams["face"] << std::hex << face;
1127 namedParams["fail"] << std::hex << fail;
1128 namedParams["zfail"] << std::hex << zfail;
1129 namedParams["zpass"] << std::hex << zpass;
1131 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1134 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1136 std::stringstream out;
1137 out << target << ", " << level << ", " << width << ", " << height;
1139 TraceCallStack::NamedParams namedParams;
1140 namedParams["target"] << std::hex << target;
1141 namedParams["level"] << level;
1142 namedParams["internalformat"] << internalformat;
1143 namedParams["width"] << width;
1144 namedParams["height"] << height;
1145 namedParams["border"] << border;
1146 namedParams["format"] << std::hex << format;
1147 namedParams["type"] << std::hex << type;
1149 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1152 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1154 std::stringstream out;
1155 out << target << ", " << pname << ", " << param;
1157 TraceCallStack::NamedParams namedParams;
1158 namedParams["target"] << std::hex << target;
1159 namedParams["pname"] << std::hex << pname;
1160 namedParams["param"] << param;
1162 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1165 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1167 std::stringstream out;
1168 out << target << ", " << pname << ", " << params[0];
1170 TraceCallStack::NamedParams namedParams;
1171 namedParams["target"] << std::hex << target;
1172 namedParams["pname"] << std::hex << pname;
1173 namedParams["params[0]"] << params[0];
1175 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1178 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1180 std::stringstream out;
1181 out << std::hex << target << ", " << pname << ", " << param;
1182 std::string params = out.str();
1184 TraceCallStack::NamedParams namedParams;
1185 namedParams["target"] << std::hex << target;
1186 namedParams["pname"] << std::hex << pname;
1187 namedParams["param"] << param;
1188 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1191 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1193 std::stringstream out;
1194 out << target << ", " << pname << ", " << params[0];
1195 TraceCallStack::NamedParams namedParams;
1196 namedParams["target"] << std::hex << target;
1197 namedParams["pname"] << std::hex << pname;
1198 namedParams["params[0]"] << params[0];
1199 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1202 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1204 std::stringstream out;
1205 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1207 TraceCallStack::NamedParams namedParams;
1208 namedParams["target"] << std::hex << target;
1209 namedParams["level"] << level;
1210 namedParams["xoffset"] << xoffset;
1211 namedParams["yoffset"] << yoffset;
1212 namedParams["width"] << width;
1213 namedParams["height"] << height;
1214 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1217 inline void Uniform1f(GLint location, GLfloat value) override
1219 std::string params = std::to_string(value);
1220 AddUniformCallToTraceStack(location, params);
1222 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1224 mGetErrorResult = GL_INVALID_OPERATION;
1228 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1231 for(int i = 0; i < count; ++i)
1233 params = params + std::to_string(v[i]) + ",";
1236 AddUniformCallToTraceStack(location, params);
1238 for(int i = 0; i < count; ++i)
1240 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1242 mGetErrorResult = GL_INVALID_OPERATION;
1248 inline void Uniform1i(GLint location, GLint x) override
1250 std::string params = std::to_string(x);
1252 AddUniformCallToTraceStack(location, params);
1254 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1256 mGetErrorResult = GL_INVALID_OPERATION;
1260 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1262 std::ostringstream out;
1263 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1264 AddUniformCallToTraceStack(location, out.str());
1266 for(int i = 0; i < count; ++i)
1268 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1272 mGetErrorResult = GL_INVALID_OPERATION;
1278 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1280 std::string params = std::to_string(x) + "," + std::to_string(y);
1281 AddUniformCallToTraceStack(location, params);
1283 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1287 mGetErrorResult = GL_INVALID_OPERATION;
1291 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1293 std::ostringstream out;
1294 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1295 AddUniformCallToTraceStack(location, out.str());
1297 for(int i = 0; i < count; ++i)
1299 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1301 Vector2(v[2 * i], v[2 * i + 1])))
1303 mGetErrorResult = GL_INVALID_OPERATION;
1309 inline void Uniform2i(GLint location, GLint x, GLint y) override
1311 std::string params = std::to_string(x) + "," + std::to_string(y);
1312 AddUniformCallToTraceStack(location, params);
1315 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1317 std::ostringstream out;
1318 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1319 AddUniformCallToTraceStack(location, out.str());
1322 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1324 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1325 AddUniformCallToTraceStack(location, params);
1327 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1331 mGetErrorResult = GL_INVALID_OPERATION;
1335 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1337 std::ostringstream out;
1338 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1339 AddUniformCallToTraceStack(location, out.str());
1341 for(int i = 0; i < count; ++i)
1343 if(!mProgramUniforms3f.SetUniformValue(
1346 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1348 mGetErrorResult = GL_INVALID_OPERATION;
1354 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1356 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1357 AddUniformCallToTraceStack(location, params);
1360 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1362 std::ostringstream out;
1363 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1364 AddUniformCallToTraceStack(location, out.str());
1367 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1369 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1370 AddUniformCallToTraceStack(location, params);
1372 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1374 Vector4(x, y, z, w)))
1376 mGetErrorResult = GL_INVALID_OPERATION;
1380 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1382 std::ostringstream out;
1383 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1384 AddUniformCallToTraceStack(location, out.str());
1386 for(int i = 0; i < count; ++i)
1388 if(!mProgramUniforms4f.SetUniformValue(
1391 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1393 mGetErrorResult = GL_INVALID_OPERATION;
1399 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1401 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1402 AddUniformCallToTraceStack(location, params);
1405 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1407 std::ostringstream out;
1408 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1409 AddUniformCallToTraceStack(location, out.str());
1412 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1414 std::ostringstream out;
1415 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1416 AddUniformCallToTraceStack(location, out.str());
1419 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1421 std::ostringstream out;
1422 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1423 AddUniformCallToTraceStack(location, out.str());
1425 for(int i = 0; i < count; ++i)
1427 if(!mProgramUniformsMat3.SetUniformValue(
1430 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1432 mGetErrorResult = GL_INVALID_OPERATION;
1438 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1440 std::ostringstream out;
1441 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1442 AddUniformCallToTraceStack(location, out.str());
1444 for(int i = 0; i < count; ++i)
1446 if(!mProgramUniformsMat4.SetUniformValue(
1451 mGetErrorResult = GL_INVALID_OPERATION;
1457 inline void UseProgram(GLuint program) override
1459 mCurrentProgram = program;
1462 inline void ValidateProgram(GLuint program) override
1466 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1470 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1474 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1478 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1482 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1486 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1490 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1494 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1498 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1500 TraceCallStack::NamedParams namedParams;
1501 namedParams["index"] << index;
1502 namedParams["size"] << size;
1503 namedParams["type"] << std::hex << type;
1504 namedParams["normalized"] << (normalized ? "T" : "F");
1505 namedParams["stride"] << stride;
1506 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1508 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1511 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1513 std::string commaString(", ");
1514 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1516 mViewportTrace.PushCall("Viewport", params);
1521 inline void ReadBuffer(GLenum mode) override
1525 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1529 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
1533 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
1537 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1541 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1545 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
1549 inline void GenQueries(GLsizei n, GLuint* ids) override
1553 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1557 inline GLboolean IsQuery(GLuint id) override
1562 inline void BeginQuery(GLenum target, GLuint id) override
1566 inline void EndQuery(GLenum target) override
1570 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1574 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1578 inline GLboolean UnmapBuffer(GLenum target) override
1582 free(mMappedBuffer);
1583 mMappedBuffer = nullptr;
1585 return true; // false indicates corruption, nothing else.
1588 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1592 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1596 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1600 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1604 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1608 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1612 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1616 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1620 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1624 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1628 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1632 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1634 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1635 return mMappedBuffer;
1638 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1642 inline void BindVertexArray(GLuint array) override
1646 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1650 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1654 inline GLboolean IsVertexArray(GLuint array) override
1659 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1663 inline void BeginTransformFeedback(GLenum primitiveMode) override
1667 inline void EndTransformFeedback(void) override
1671 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1675 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1679 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1683 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1687 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1691 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1695 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1699 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1703 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1707 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1711 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1715 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1719 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1724 inline void Uniform1ui(GLint location, GLuint v0) override
1728 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1732 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1736 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1740 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1744 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1748 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1752 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1756 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1760 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1764 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1768 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1772 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1777 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1781 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1785 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1789 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1791 return GL_INVALID_INDEX;
1794 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1798 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1802 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1806 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1810 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1814 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1819 inline GLboolean IsSync(GLsync sync) override
1824 inline void DeleteSync(GLsync sync) override
1828 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1833 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1837 inline void GetInteger64v(GLenum pname, GLint64* params) override
1841 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1845 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1849 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1853 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1857 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1861 inline GLboolean IsSampler(GLuint sampler) override
1866 inline void BindSampler(GLuint unit, GLuint sampler) override
1870 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1874 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1878 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1882 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1886 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1890 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1894 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1898 inline void BindTransformFeedback(GLenum target, GLuint id) override
1902 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1906 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1910 inline GLboolean IsTransformFeedback(GLuint id) override
1915 inline void PauseTransformFeedback(void) override
1919 inline void ResumeTransformFeedback(void) override
1923 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1925 mGetProgramBinaryCalled = true;
1928 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1932 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1936 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1940 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1944 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1948 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1952 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1956 inline void BlendBarrier(void)
1961 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1963 std::string name = "<not found>";
1964 bool matched = false;
1966 UniformIDMap& map = mUniforms[mCurrentProgram];
1967 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1969 if(it->second == location)
1979 mSetUniformTrace.PushCall(name, value);
1983 public: // TEST FUNCTIONS
1984 inline void SetCompileStatus(GLuint value)
1986 mCompileStatus = value;
1988 inline void SetLinkStatus(GLuint value)
1990 mLinkStatus = value;
1992 inline void SetAttribLocations(std::vector<std::string> locs)
1996 inline void SetGetErrorResult(GLenum result)
1998 mGetErrorResult = result;
2000 inline void SetGetStringResult(GLubyte* result)
2002 mGetStringResult = result;
2004 inline void SetIsBufferResult(GLboolean result)
2006 mIsBufferResult = result;
2008 inline void SetIsEnabledResult(GLboolean result)
2010 mIsEnabledResult = result;
2012 inline void SetIsFramebufferResult(GLboolean result)
2014 mIsFramebufferResult = result;
2016 inline void SetIsProgramResult(GLboolean result)
2018 mIsProgramResult = result;
2020 inline void SetIsRenderbufferResult(GLboolean result)
2022 mIsRenderbufferResult = result;
2024 inline void SetIsShaderResult(GLboolean result)
2026 mIsShaderResult = result;
2028 inline void SetIsTextureResult(GLboolean result)
2030 mIsTextureResult = result;
2032 inline void SetCheckFramebufferStatusResult(GLenum result)
2034 mCheckFramebufferStatusResult = result;
2036 inline void SetNumBinaryFormats(GLint numFormats)
2038 mNumBinaryFormats = numFormats;
2040 inline void SetBinaryFormats(GLint binaryFormats)
2042 mBinaryFormats = binaryFormats;
2044 inline void SetProgramBinaryLength(GLint length)
2046 mProgramBinaryLength = length;
2049 inline bool GetVertexAttribArrayState(GLuint index)
2051 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2056 return mVertexAttribArrayState[index];
2058 inline void ClearVertexAttribArrayChanged()
2060 mVertexAttribArrayChanged = false;
2062 inline bool GetVertexAttribArrayChanged()
2064 return mVertexAttribArrayChanged;
2067 //Methods for CullFace verification
2068 inline void EnableCullFaceCallTrace(bool enable)
2070 mCullFaceTrace.Enable(enable);
2072 inline void ResetCullFaceCallStack()
2074 mCullFaceTrace.Reset();
2076 inline TraceCallStack& GetCullFaceTrace()
2078 return mCullFaceTrace;
2081 //Methods for Enable/Disable call verification
2082 inline void EnableEnableDisableCallTrace(bool enable)
2084 mEnableDisableTrace.Enable(enable);
2086 inline void ResetEnableDisableCallStack()
2088 mEnableDisableTrace.Reset();
2090 inline TraceCallStack& GetEnableDisableTrace()
2092 return mEnableDisableTrace;
2095 //Methods for Shader verification
2096 inline void EnableShaderCallTrace(bool enable)
2098 mShaderTrace.Enable(enable);
2100 inline void ResetShaderCallStack()
2102 mShaderTrace.Reset();
2104 inline TraceCallStack& GetShaderTrace()
2106 return mShaderTrace;
2109 //Methods for Texture verification
2110 inline void EnableTextureCallTrace(bool enable)
2112 mTextureTrace.Enable(enable);
2114 inline void ResetTextureCallStack()
2116 mTextureTrace.Reset();
2118 inline TraceCallStack& GetTextureTrace()
2120 return mTextureTrace;
2123 //Methods for Texture verification
2124 inline void EnableTexParameterCallTrace(bool enable)
2126 mTexParameterTrace.Enable(enable);
2128 inline void ResetTexParameterCallStack()
2130 mTexParameterTrace.Reset();
2132 inline TraceCallStack& GetTexParameterTrace()
2134 return mTexParameterTrace;
2137 //Methods for Draw verification
2138 inline void EnableDrawCallTrace(bool enable)
2140 mDrawTrace.Enable(enable);
2142 inline void ResetDrawCallStack()
2146 inline TraceCallStack& GetDrawTrace()
2151 //Methods for Depth function verification
2152 inline void EnableDepthFunctionCallTrace(bool enable)
2154 mDepthFunctionTrace.Enable(enable);
2156 inline void ResetDepthFunctionCallStack()
2158 mDepthFunctionTrace.Reset();
2160 inline TraceCallStack& GetDepthFunctionTrace()
2162 return mDepthFunctionTrace;
2165 //Methods for Stencil function verification
2166 inline void EnableStencilFunctionCallTrace(bool enable)
2168 mStencilFunctionTrace.Enable(enable);
2170 inline void ResetStencilFunctionCallStack()
2172 mStencilFunctionTrace.Reset();
2174 inline TraceCallStack& GetStencilFunctionTrace()
2176 return mStencilFunctionTrace;
2179 //Methods for Scissor verification
2180 inline void EnableScissorCallTrace(bool enable)
2182 mScissorTrace.Enable(enable);
2184 inline void ResetScissorCallStack()
2186 mScissorTrace.Reset();
2188 inline TraceCallStack& GetScissorTrace()
2190 return mScissorTrace;
2193 //Methods for Uniform function verification
2194 inline void EnableSetUniformCallTrace(bool enable)
2196 mSetUniformTrace.Enable(enable);
2198 inline void ResetSetUniformCallStack()
2200 mSetUniformTrace.Reset();
2202 inline TraceCallStack& GetSetUniformTrace()
2204 return mSetUniformTrace;
2207 //Methods for Viewport verification
2208 inline void EnableViewportCallTrace(bool enable)
2210 mViewportTrace.Enable(enable);
2212 inline void ResetViewportCallStack()
2214 mViewportTrace.Reset();
2216 inline TraceCallStack& GetViewportTrace()
2218 return mViewportTrace;
2220 inline TraceCallStack& GetBufferTrace()
2222 return mBufferTrace;
2225 template<typename T>
2226 inline bool GetUniformValue(const char* name, T& value) const
2228 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2229 program_it != mUniforms.end();
2232 const UniformIDMap& uniformIDs = program_it->second;
2234 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2235 if(uniform_it != uniformIDs.end())
2237 // found one matching uniform name, lets check the value...
2238 GLuint programId = program_it->first;
2239 GLint uniformId = uniform_it->second;
2241 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2242 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2248 template<typename T>
2249 inline bool CheckUniformValue(const char* name, const T& value) const
2251 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2252 program_it != mUniforms.end();
2255 const UniformIDMap& uniformIDs = program_it->second;
2257 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2258 if(uniform_it != uniformIDs.end())
2260 // found one matching uniform name, lets check the value...
2261 GLuint programId = program_it->first;
2262 GLint uniformId = uniform_it->second;
2264 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2265 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2267 // the value matches
2273 fprintf(stderr, "Not found, printing possible values:\n");
2274 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2275 program_it != mUniforms.end();
2278 const UniformIDMap& uniformIDs = program_it->second;
2280 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2281 if(uniform_it != uniformIDs.end())
2283 // found one matching uniform name, lets check the value...
2284 GLuint programId = program_it->first;
2285 GLint uniformId = uniform_it->second;
2287 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2289 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2291 std::stringstream out;
2292 out << uniform_it->first << ": " << origValue;
2293 fprintf(stderr, "%s\n", out.str().c_str());
2300 template<typename T>
2301 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2303 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2304 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2307 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
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 programId = program_it->first;
2319 uniformId = uniform_it->second;
2326 inline GLuint GetLastShaderCompiled() const
2328 return mLastShaderCompiled;
2331 inline GLuint GetLastProgramCreated() const
2333 return mLastProgramIdUsed;
2336 inline GLbitfield GetLastClearMask() const
2338 return mLastClearBitMask;
2343 ATTRIB_UNKNOWN = -1,
2348 ATTRIB_BONE_WEIGHTS,
2349 ATTRIB_BONE_INDICES,
2353 struct ScissorParams
2369 // Methods to check scissor tests
2370 inline const ScissorParams& GetScissorParams() const
2372 return mScissorParams;
2375 struct ColorMaskParams
2391 inline bool GetProgramBinaryCalled() const
2393 return mGetProgramBinaryCalled;
2396 inline unsigned int GetClearCountCalled() const
2401 inline const ColorMaskParams& GetColorMaskParams() const
2403 return mColorMaskParams;
2406 typedef std::vector<size_t> BufferDataCalls;
2407 inline const BufferDataCalls& GetBufferDataCalls() const
2409 return mBufferDataCalls;
2411 inline void ResetBufferDataCalls()
2413 mBufferDataCalls.clear();
2416 typedef std::vector<size_t> BufferSubDataCalls;
2417 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2419 return mBufferSubDataCalls;
2421 inline void ResetBufferSubDataCalls()
2423 mBufferSubDataCalls.clear();
2427 GLuint mCurrentProgram;
2428 GLuint mCompileStatus;
2429 BufferDataCalls mBufferDataCalls;
2430 BufferSubDataCalls mBufferSubDataCalls;
2431 GLvoid* mMappedBuffer{nullptr};
2433 GLint mNumberOfActiveUniforms;
2434 GLenum mGetErrorResult;
2435 GLubyte* mGetStringResult;
2436 GLboolean mIsBufferResult;
2437 GLboolean mIsEnabledResult;
2438 GLboolean mIsFramebufferResult;
2439 GLboolean mIsProgramResult;
2440 GLboolean mIsRenderbufferResult;
2441 GLboolean mIsShaderResult;
2442 GLboolean mIsTextureResult;
2443 GLenum mActiveTextureUnit;
2444 GLenum mCheckFramebufferStatusResult;
2445 GLint mFramebufferStatus;
2446 GLenum mFramebufferDepthAttached;
2447 GLenum mFramebufferStencilAttached;
2448 GLuint mFramebufferColorAttachmentCount;
2449 GLuint mFrameBufferColorStatus;
2450 GLint mNumBinaryFormats;
2451 GLint mBinaryFormats;
2452 GLint mProgramBinaryLength;
2453 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2454 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2455 bool mGetProgramBinaryCalled;
2456 typedef std::map<GLuint, std::string> ShaderSourceMap;
2457 ShaderSourceMap mShaderSources;
2458 std::vector<std::string> mAttribLocs; // should be bound to shader
2459 GLuint mLastShaderCompiled;
2460 GLbitfield mLastClearBitMask;
2461 Vector4 mLastClearColor;
2462 unsigned int mClearCount;
2464 Vector4 mLastBlendColor;
2465 GLenum mLastBlendEquationRgb;
2466 GLenum mLastBlendEquationAlpha;
2467 GLenum mLastBlendFuncSrcRgb;
2468 GLenum mLastBlendFuncDstRgb;
2469 GLenum mLastBlendFuncSrcAlpha;
2470 GLenum mLastBlendFuncDstAlpha;
2472 GLboolean mLastDepthMask;
2474 // Data for manipulating the IDs returned by GenTextures
2475 GLuint mLastAutoTextureIdUsed;
2476 GLuint mNumGeneratedTextures;
2477 std::vector<GLuint> mNextTextureIds;
2478 std::vector<GLuint> mDeletedTextureIds;
2479 std::vector<GLuint> mBoundTextures;
2481 struct ActiveTextureType
2483 std::vector<GLuint> mBoundTextures;
2486 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2488 TraceCallStack mBufferTrace;
2489 TraceCallStack mCullFaceTrace;
2490 TraceCallStack mEnableDisableTrace;
2491 TraceCallStack mShaderTrace;
2492 TraceCallStack mTextureTrace;
2493 TraceCallStack mTexParameterTrace;
2494 TraceCallStack mDrawTrace;
2495 TraceCallStack mDepthFunctionTrace;
2496 TraceCallStack mStencilFunctionTrace;
2497 TraceCallStack mScissorTrace;
2498 TraceCallStack mSetUniformTrace;
2499 TraceCallStack mViewportTrace;
2501 // Shaders & Uniforms
2502 GLuint mLastShaderIdUsed;
2503 GLuint mLastProgramIdUsed{0u};
2504 GLuint mLastUniformIdUsed;
2505 typedef std::map<std::string, GLint> UniformIDMap;
2506 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2507 ProgramUniformMap mUniforms;
2509 template<typename T>
2510 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2513 typedef std::map<GLint, T> UniformValueMap;
2514 typedef std::map<GLuint, UniformValueMap> Map;
2516 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2523 typename Map::iterator it = Map::find(program);
2524 if(it == Map::end())
2526 // if its the first uniform for this program add it
2527 std::pair<typename Map::iterator, bool> result =
2528 Map::insert(typename Map::value_type(program, UniformValueMap()));
2532 UniformValueMap& uniforms = it->second;
2533 uniforms[uniform] = value;
2538 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2541 if(GetUniformValue(program, uniform, uniformValue))
2543 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2549 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2556 typename Map::const_iterator it = Map::find(program);
2557 if(it == Map::end())
2559 // Uniform values always initialised as 0
2564 const UniformValueMap& uniforms = it->second;
2565 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2566 if(it2 == uniforms.end())
2568 // Uniform values always initialised as 0
2572 value = it2->second;
2579 ProgramUniformValue<int> mProgramUniforms1i;
2580 ProgramUniformValue<float> mProgramUniforms1f;
2581 ProgramUniformValue<Vector2> mProgramUniforms2f;
2582 ProgramUniformValue<Vector3> mProgramUniforms3f;
2583 ProgramUniformValue<Vector4> mProgramUniforms4f;
2584 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2585 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2587 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2589 return mProgramUniforms1i;
2591 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2593 return mProgramUniforms1f;
2595 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2597 return mProgramUniforms2f;
2599 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2601 return mProgramUniforms3f;
2603 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2605 return mProgramUniforms4f;
2607 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2609 return mProgramUniformsMat4;
2611 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2613 return mProgramUniformsMat3;
2615 inline void SetVertexAttribArray(GLuint index, bool state)
2617 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2622 mVertexAttribArrayState[index] = state;
2623 mVertexAttribArrayChanged = true;
2626 ScissorParams mScissorParams;
2627 ColorMaskParams mColorMaskParams;
2631 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2637 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2643 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2645 return Vector2::ZERO;
2649 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2651 return Vector3::ZERO;
2655 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2657 return Vector4::ZERO;
2661 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2667 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2669 return Matrix3(Matrix());
2674 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2675 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2677 #endif // TEST_GL_ABSTRACTION_H