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 static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 64;
42 static const char* mStdAttribs[MAX_ATTRIBUTE_CACHE_SIZE] =
44 "aPosition", // ATTRIB_POSITION
45 "aNormal", // ATTRIB_NORMAL
46 "aTexCoord", // ATTRIB_TEXCOORD
47 "aColor", // ATTRIB_COLOR
48 "aBoneWeights", // ATTRIB_BONE_WEIGHTS
49 "aBoneIndices" // ATTRIB_BONE_INDICES
52 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
56 ~TestGlAbstraction() override;
59 void PreRender() override;
60 void PostRender() override;
62 bool IsSurfacelessContextSupported() const override;
64 bool IsAdvancedBlendEquationSupported() override;
66 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
68 std::string GetShaderVersionPrefix();
70 std::string GetVertexShaderPrefix();
72 std::string GetFragmentShaderPrefix();
74 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
78 inline void ActiveTexture(GLenum textureUnit) override
80 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
83 inline GLenum GetActiveTextureUnit() const
85 return mActiveTextureUnit + GL_TEXTURE0;
88 inline void AttachShader(GLuint program, GLuint shader) override
90 std::stringstream out;
91 out << program << ", " << shader;
93 TraceCallStack::NamedParams namedParams;
94 namedParams["program"] = ToString(program);
95 namedParams["shader"] = ToString(shader);
96 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
99 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
103 inline void BindBuffer(GLenum target, GLuint buffer) override
105 std::ostringstream o;
106 o << std::hex << target << ", " << buffer;
107 TraceCallStack::NamedParams namedParams;
108 namedParams["target"] = target;
109 namedParams["buffer"] = buffer;
110 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
113 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
116 mFramebufferStatus |= 2;
119 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
124 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
125 * @return A vector containing the IDs that were bound.
127 inline const std::vector<GLuint>& GetBoundTextures() const
129 return mBoundTextures;
133 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
134 * @param[in] activeTextureUnit The specific active texture unit.
135 * @return A vector containing the IDs that were bound.
137 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
139 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
143 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
145 inline void ClearBoundTextures()
147 mBoundTextures.clear();
149 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
151 mActiveTextures[i].mBoundTextures.clear();
155 inline void BindTexture(GLenum target, GLuint texture) override
157 // Record the bound textures for future checks
160 mBoundTextures.push_back(texture);
162 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
164 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
168 std::stringstream out;
169 out << target << ", " << texture;
171 TraceCallStack::NamedParams namedParams;
172 namedParams["target"] = ToString(target);
173 namedParams["texture"] = ToString(texture);
175 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
178 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
180 mLastBlendColor.r = red;
181 mLastBlendColor.g = green;
182 mLastBlendColor.b = blue;
183 mLastBlendColor.a = alpha;
186 inline const Vector4& GetLastBlendColor() const
188 return mLastBlendColor;
191 inline void BlendEquation(GLenum mode) override
193 mLastBlendEquationRgb = mode;
194 mLastBlendEquationAlpha = mode;
197 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
199 mLastBlendEquationRgb = modeRgb;
200 mLastBlendEquationAlpha = modeAlpha;
203 inline GLenum GetLastBlendEquationRgb() const
205 return mLastBlendEquationRgb;
208 inline GLenum GetLastBlendEquationAlpha() const
210 return mLastBlendEquationAlpha;
213 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
215 mLastBlendFuncSrcRgb = sfactor;
216 mLastBlendFuncDstRgb = dfactor;
217 mLastBlendFuncSrcAlpha = sfactor;
218 mLastBlendFuncDstAlpha = dfactor;
221 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
223 mLastBlendFuncSrcRgb = srcRGB;
224 mLastBlendFuncDstRgb = dstRGB;
225 mLastBlendFuncSrcAlpha = srcAlpha;
226 mLastBlendFuncDstAlpha = dstAlpha;
229 inline GLenum GetLastBlendFuncSrcRgb() const
231 return mLastBlendFuncSrcRgb;
234 inline GLenum GetLastBlendFuncDstRgb() const
236 return mLastBlendFuncDstRgb;
239 inline GLenum GetLastBlendFuncSrcAlpha() const
241 return mLastBlendFuncSrcAlpha;
244 inline GLenum GetLastBlendFuncDstAlpha() const
246 return mLastBlendFuncDstAlpha;
249 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
251 std::ostringstream o;
252 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
253 TraceCallStack::NamedParams namedParams;
254 namedParams["target"] = target;
255 namedParams["size"] = size;
256 namedParams["usage"] = usage;
258 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
260 mBufferDataCalls.push_back(size);
263 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
265 std::ostringstream o;
266 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
267 TraceCallStack::NamedParams namedParams;
268 namedParams["target"] = target;
269 namedParams["offset"] = offset;
270 namedParams["size"] = size;
271 mBufferTrace.PushCall("BufferSubData", o.str());
273 mBufferSubDataCalls.push_back(size);
276 inline GLenum CheckFramebufferStatus(GLenum target) override
278 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
279 //Framebuffer texture have been called
280 if(mFramebufferStatus == 7)
282 return GL_FRAMEBUFFER_COMPLETE;
285 return mCheckFramebufferStatusResult;
288 inline GLuint CheckFramebufferColorAttachmentCount()
290 return mFramebufferColorAttachmentCount;
293 inline GLenum CheckFramebufferDepthAttachment()
295 return mFramebufferDepthAttached;
298 inline GLenum CheckFramebufferStencilAttachment()
300 return mFramebufferStencilAttached;
303 inline void Clear(GLbitfield mask) override
306 mLastClearBitMask = mask;
309 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
311 mLastClearColor.r = red;
312 mLastClearColor.g = green;
313 mLastClearColor.b = blue;
314 mLastClearColor.a = alpha;
317 inline const Vector4& GetLastClearColor() const
319 return mLastClearColor;
322 inline void ClearDepthf(GLclampf depth) override
326 inline void ClearStencil(GLint s) override
328 std::stringstream out;
331 TraceCallStack::NamedParams namedParams;
332 namedParams["s"] = ToString(s);
334 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
337 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
339 mColorMaskParams.red = red;
340 mColorMaskParams.green = green;
341 mColorMaskParams.blue = blue;
342 mColorMaskParams.alpha = alpha;
345 inline void CompileShader(GLuint shader) override
347 std::stringstream out;
349 TraceCallStack::NamedParams namedParams;
350 namedParams["shader"] = ToString(shader);
352 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
355 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
357 std::stringstream out;
358 out << target << ", " << level << ", " << width << ", " << height;
360 TraceCallStack::NamedParams namedParams;
361 namedParams["target"] = ToString(target);
362 namedParams["level"] = ToString(level);
363 namedParams["internalformat"] = ToString(internalformat);
364 namedParams["width"] = ToString(width);
365 namedParams["height"] = ToString(height);
366 namedParams["border"] = ToString(border);
367 namedParams["size"] = ToString(imageSize);
369 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
372 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
374 std::stringstream out;
375 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
377 TraceCallStack::NamedParams namedParams;
378 namedParams["target"] = ToString(target);
379 namedParams["level"] = ToString(level);
380 namedParams["xoffset"] = ToString(xoffset);
381 namedParams["yoffset"] = ToString(yoffset);
382 namedParams["width"] = ToString(width);
383 namedParams["height"] = ToString(height);
384 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
387 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
391 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
395 inline GLuint CreateProgram(void) override
397 mShaderTrace.PushCall("CreateProgram", "");
399 ++mLastProgramIdUsed;
400 mUniforms[mLastProgramIdUsed] = UniformIDMap();
401 return mLastProgramIdUsed;
404 inline GLuint CreateShader(GLenum type) override
406 std::stringstream out;
409 TraceCallStack::NamedParams namedParams;
410 namedParams["type"] = ToString(type);
411 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
413 return ++mLastShaderIdUsed;
416 inline void CullFace(GLenum mode) override
418 std::stringstream out;
421 TraceCallStack::NamedParams namedParams;
422 namedParams["program"] = ToString(mode);
424 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
427 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
431 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
435 inline void DeleteProgram(GLuint program) override
437 std::stringstream out;
440 TraceCallStack::NamedParams namedParams;
441 namedParams["program"] = ToString(program);
443 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
446 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
450 inline void DeleteShader(GLuint shader) override
452 std::stringstream out;
455 TraceCallStack::NamedParams namedParams;
456 namedParams["shader"] = ToString(shader);
458 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
461 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
463 std::stringstream out;
464 out << "n:" << n << " textures[";
466 TraceCallStack::NamedParams namedParams;
468 for(GLsizei i = 0; i < n; i++)
470 out << (i > 0 ? ", " : "") << textures[i];
471 std::stringstream paramName;
472 paramName << "texture[" << i << "]";
473 namedParams[paramName.str()] = ToString(textures[i]);
474 mDeletedTextureIds.push_back(textures[i]);
475 mNumGeneratedTextures--;
479 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
482 inline bool CheckNoTexturesDeleted()
484 return mDeletedTextureIds.size() == 0;
487 inline bool CheckTextureDeleted(GLuint textureId)
491 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
493 if(*iter == textureId)
502 inline void ClearDeletedTextures()
504 mDeletedTextureIds.clear();
507 inline void DepthFunc(GLenum func) override
509 std::stringstream out;
512 TraceCallStack::NamedParams namedParams;
513 namedParams["func"] = ToString(func);
515 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
518 inline void DepthMask(GLboolean flag) override
520 mLastDepthMask = flag;
523 inline bool GetLastDepthMask() const
525 return mLastDepthMask;
528 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
532 inline void DetachShader(GLuint program, GLuint shader) override
534 std::stringstream out;
535 out << program << ", " << shader;
536 TraceCallStack::NamedParams namedParams;
537 namedParams["program"] = ToString(program);
538 namedParams["shader"] = ToString(shader);
539 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
542 inline void Disable(GLenum cap) override
544 std::stringstream out;
546 TraceCallStack::NamedParams namedParams;
547 namedParams["cap"] = ToString(cap);
548 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
551 inline void DisableVertexAttribArray(GLuint index) override
553 SetVertexAttribArray(index, false);
556 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
558 std::stringstream out;
559 out << mode << ", " << first << ", " << count;
560 TraceCallStack::NamedParams namedParams;
561 namedParams["mode"] = ToString(mode);
562 namedParams["first"] = ToString(first);
563 namedParams["count"] = ToString(count);
564 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
567 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
569 std::stringstream out;
570 out << mode << ", " << count << ", " << type << ", indices";
572 TraceCallStack::NamedParams namedParams;
573 namedParams["mode"] = ToString(mode);
574 namedParams["count"] = ToString(count);
575 namedParams["type"] = ToString(type);
576 // Skip void pointers - are they of any use?
577 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
580 inline void Enable(GLenum cap) override
582 std::stringstream out;
584 TraceCallStack::NamedParams namedParams;
585 namedParams["cap"] = ToString(cap);
586 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
589 inline void EnableVertexAttribArray(GLuint index) override
591 SetVertexAttribArray(index, true);
594 inline void Finish(void) override
598 inline void Flush(void) override
602 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
604 if(attachment == GL_DEPTH_ATTACHMENT)
606 mFramebufferDepthAttached = true;
608 else if(attachment == GL_STENCIL_ATTACHMENT)
610 mFramebufferStencilAttached = true;
614 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
617 mFramebufferStatus |= 4;
619 //We check 4 attachment colors
620 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
622 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
623 if((mFrameBufferColorStatus & mask) == 0)
625 mFrameBufferColorStatus |= mask;
626 ++mFramebufferColorAttachmentCount;
631 inline void FrontFace(GLenum mode) override
635 inline void GenBuffers(GLsizei n, GLuint* buffers) override
637 // avoids an assert in GpuBuffers
640 std::ostringstream o;
642 TraceCallStack::NamedParams namedParams;
643 namedParams["n"] = o.str();
644 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
647 inline void GenerateMipmap(GLenum target) override
649 std::stringstream out;
651 TraceCallStack::NamedParams namedParams;
652 namedParams["target"] = ToString(target);
654 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
657 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
659 for(int i = 0; i < n; i++)
661 framebuffers[i] = i + 1;
664 //Add 001 bit, this function needs to be called the first one in the chain
665 mFramebufferStatus = 1;
668 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
670 for(int i = 0; i < n; i++)
672 renderbuffers[i] = i + 1;
677 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
678 * @param[in] ids A vector containing the next IDs to be generated
680 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
682 mNextTextureIds = ids;
685 inline const std::vector<GLuint>& GetNextTextureIds()
687 return mNextTextureIds;
690 inline void GenTextures(GLsizei count, GLuint* textures) override
692 for(int i = 0; i < count; ++i)
694 if(!mNextTextureIds.empty())
696 *(textures + i) = mNextTextureIds[0];
697 mNextTextureIds.erase(mNextTextureIds.begin());
701 *(textures + i) = ++mLastAutoTextureIdUsed;
703 mNumGeneratedTextures++;
706 TraceCallStack::NamedParams namedParams;
707 namedParams["count"] = ToString(count);
709 std::stringstream out;
710 for(int i = 0; i < count; i++)
717 std::ostringstream oss;
718 oss << "indices[" << i << "]";
719 namedParams[oss.str()] = ToString(textures[i]);
722 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
725 inline GLuint GetLastGenTextureId()
727 return mLastAutoTextureIdUsed;
730 inline GLuint GetNumGeneratedTextures()
732 return mNumGeneratedTextures;
735 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
739 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
744 *length = snprintf(name, bufsize, "sTexture");
745 *type = GL_SAMPLER_2D;
749 *length = snprintf(name, bufsize, "sEffect");
750 *type = GL_SAMPLER_2D;
754 *length = snprintf(name, bufsize, "sGloss");
755 *type = GL_SAMPLER_2D;
763 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
767 inline int GetAttribLocation(GLuint program, const char* name) override
769 std::string attribName(name);
771 for(unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i)
773 if(mStdAttribs[i] == attribName)
779 // 0 is a valid location
783 inline void GetBooleanv(GLenum pname, GLboolean* params) override
787 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
791 inline GLenum GetError(void) override
793 return mGetErrorResult;
796 inline void GetFloatv(GLenum pname, GLfloat* params) override
800 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
804 inline void GetIntegerv(GLenum pname, GLint* params) override
808 case GL_MAX_TEXTURE_SIZE:
811 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
814 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
815 *params = mNumBinaryFormats;
817 case GL_PROGRAM_BINARY_FORMATS_OES:
818 *params = mBinaryFormats;
823 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
828 *params = mLinkStatus;
830 case GL_PROGRAM_BINARY_LENGTH_OES:
831 *params = mProgramBinaryLength;
833 case GL_ACTIVE_UNIFORMS:
834 *params = mNumberOfActiveUniforms;
836 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
842 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
846 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
850 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
854 case GL_COMPILE_STATUS:
855 *params = mCompileStatus;
860 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
864 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
868 inline const GLubyte* GetString(GLenum name) override
870 return mGetStringResult;
873 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
877 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
881 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
885 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
889 inline GLint GetUniformLocation(GLuint program, const char* name) override
891 ProgramUniformMap::iterator it = mUniforms.find(program);
892 if(it == mUniforms.end())
894 // Not a valid program ID
895 mGetErrorResult = GL_INVALID_OPERATION;
899 UniformIDMap& uniformIDs = it->second;
900 UniformIDMap::iterator it2 = uniformIDs.find(name);
901 if(it2 == uniformIDs.end())
903 // Uniform not found, so add it...
904 uniformIDs[name] = ++mLastUniformIdUsed;
905 return mLastUniformIdUsed;
911 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
915 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
919 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
923 inline void Hint(GLenum target, GLenum mode) override
927 inline GLboolean IsBuffer(GLuint buffer) override
929 return mIsBufferResult;
932 inline GLboolean IsEnabled(GLenum cap) override
934 return mIsEnabledResult;
937 inline GLboolean IsFramebuffer(GLuint framebuffer) override
939 return mIsFramebufferResult;
942 inline GLboolean IsProgram(GLuint program) override
944 return mIsProgramResult;
947 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
949 return mIsRenderbufferResult;
952 inline GLboolean IsShader(GLuint shader) override
954 return mIsShaderResult;
957 inline GLboolean IsTexture(GLuint texture) override
959 return mIsTextureResult;
962 inline void LineWidth(GLfloat width) override
966 inline void LinkProgram(GLuint program) override
968 std::stringstream out;
971 TraceCallStack::NamedParams namedParams;
972 namedParams["program"] = ToString(program);
973 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
975 mNumberOfActiveUniforms = 3;
976 GetUniformLocation(program, "sTexture");
977 GetUniformLocation(program, "sEffect");
978 GetUniformLocation(program, "sGloss");
981 inline void PixelStorei(GLenum pname, GLint param) override
985 inline void PolygonOffset(GLfloat factor, GLfloat units) override
989 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
993 inline void ReleaseShaderCompiler(void) override
997 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1001 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1005 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1007 mScissorParams.x = x;
1008 mScissorParams.y = y;
1009 mScissorParams.width = width;
1010 mScissorParams.height = height;
1012 std::stringstream out;
1013 out << x << ", " << y << ", " << width << ", " << height;
1014 TraceCallStack::NamedParams namedParams;
1015 namedParams["x"] = ToString(x);
1016 namedParams["y"] = ToString(y);
1017 namedParams["width"] = ToString(width);
1018 namedParams["height"] = ToString(height);
1019 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1022 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1026 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1028 std::string stringBuilder;
1029 for(int i = 0; i < count; ++i)
1031 stringBuilder += string[i];
1033 mShaderSources[shader] = stringBuilder;
1034 mLastShaderCompiled = shader;
1037 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1039 const std::string shaderSource = mShaderSources[shader];
1040 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1041 if(shaderSourceLength < bufsize)
1043 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1044 *length = shaderSourceLength;
1048 *length = bufsize - 1;
1049 strncpy(source, shaderSource.c_str(), *length);
1050 source[*length] = 0x0;
1054 inline std::string GetShaderSource(GLuint shader)
1056 return mShaderSources[shader];
1059 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1061 std::stringstream out;
1062 out << func << ", " << ref << ", " << mask;
1064 TraceCallStack::NamedParams namedParams;
1065 namedParams["func"] = ToString(func);
1066 namedParams["ref"] = ToString(ref);
1067 namedParams["mask"] = ToString(mask);
1069 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1072 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1074 std::stringstream out;
1075 out << face << ", " << func << ", " << ref << ", " << mask;
1077 TraceCallStack::NamedParams namedParams;
1078 namedParams["face"] = ToString(face);
1079 namedParams["func"] = ToString(func);
1080 namedParams["ref"] = ToString(ref);
1081 namedParams["mask"] = ToString(mask);
1083 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1086 inline void StencilMask(GLuint mask) override
1088 std::stringstream out;
1091 TraceCallStack::NamedParams namedParams;
1092 namedParams["mask"] = ToString(mask);
1094 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1097 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1099 std::stringstream out;
1100 out << face << ", " << mask;
1102 TraceCallStack::NamedParams namedParams;
1103 namedParams["face"] = ToString(face);
1104 namedParams["mask"] = ToString(mask);
1106 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1109 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1111 std::stringstream out;
1112 out << fail << ", " << zfail << ", " << zpass;
1114 TraceCallStack::NamedParams namedParams;
1115 namedParams["fail"] = ToString(fail);
1116 namedParams["zfail"] = ToString(zfail);
1117 namedParams["zpass"] = ToString(zpass);
1119 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1122 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1124 std::stringstream out;
1125 out << face << ", " << fail << ", " << zfail << "," << zpass;
1127 TraceCallStack::NamedParams namedParams;
1128 namedParams["face"] = ToString(face);
1129 namedParams["fail"] = ToString(fail);
1130 namedParams["zfail"] = ToString(zfail);
1131 namedParams["zpass"] = ToString(zpass);
1133 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1136 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1138 std::stringstream out;
1139 out << target << ", " << level << ", " << width << ", " << height;
1141 TraceCallStack::NamedParams namedParams;
1142 namedParams["target"] = ToString(target);
1143 namedParams["level"] = ToString(level);
1144 namedParams["internalformat"] = ToString(internalformat);
1145 namedParams["width"] = ToString(width);
1146 namedParams["height"] = ToString(height);
1147 namedParams["border"] = ToString(border);
1148 namedParams["format"] = ToString(format);
1149 namedParams["type"] = ToString(type);
1151 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1154 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1156 std::stringstream out;
1157 out << target << ", " << pname << ", " << param;
1159 TraceCallStack::NamedParams namedParams;
1160 namedParams["target"] = ToString(target);
1161 namedParams["pname"] = ToString(pname);
1162 namedParams["param"] = ToString(param);
1164 mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
1167 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1169 std::stringstream out;
1170 out << target << ", " << pname << ", " << params[0];
1172 TraceCallStack::NamedParams namedParams;
1173 namedParams["target"] = ToString(target);
1174 namedParams["pname"] = ToString(pname);
1175 namedParams["params[0]"] = ToString(params[0]);
1177 mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1180 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1182 std::stringstream out;
1183 out << std::hex << target << ", " << pname << ", " << param;
1184 std::string params = out.str();
1187 out << std::hex << target;
1188 TraceCallStack::NamedParams namedParams;
1189 namedParams["target"] = out.str();
1191 out << std::hex << pname;
1192 namedParams["pname"] = out.str();
1194 out << std::hex << param;
1195 namedParams["param"] = out.str();
1196 mTexParamaterTrace.PushCall("TexParameteri", params, namedParams);
1199 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1201 std::stringstream out;
1202 out << target << ", " << pname << ", " << params[0];
1203 TraceCallStack::NamedParams namedParams;
1204 namedParams["target"] = ToString(target);
1205 namedParams["pname"] = ToString(pname);
1206 namedParams["params[0]"] = ToString(params[0]);
1207 mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1210 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1212 std::stringstream out;
1213 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1215 TraceCallStack::NamedParams namedParams;
1216 namedParams["target"] = ToString(target);
1217 namedParams["level"] = ToString(level);
1218 namedParams["xoffset"] = ToString(xoffset);
1219 namedParams["yoffset"] = ToString(yoffset);
1220 namedParams["width"] = ToString(width);
1221 namedParams["height"] = ToString(height);
1222 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1225 inline void Uniform1f(GLint location, GLfloat value) override
1227 std::string params = ToString(value);
1228 AddUniformCallToTraceStack(location, params);
1230 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1232 mGetErrorResult = GL_INVALID_OPERATION;
1236 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1239 for(int i = 0; i < count; ++i)
1241 params = params + ToString(v[i]) + ",";
1244 AddUniformCallToTraceStack(location, params);
1246 for(int i = 0; i < count; ++i)
1248 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1250 mGetErrorResult = GL_INVALID_OPERATION;
1256 inline void Uniform1i(GLint location, GLint x) override
1258 std::string params = ToString(x);
1260 AddUniformCallToTraceStack(location, params);
1262 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1264 mGetErrorResult = GL_INVALID_OPERATION;
1268 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1270 std::string params = ToString(v);
1271 AddUniformCallToTraceStack(location, params);
1273 for(int i = 0; i < count; ++i)
1275 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1279 mGetErrorResult = GL_INVALID_OPERATION;
1285 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1287 std::string params = ToString(x) + "," + ToString(y);
1288 AddUniformCallToTraceStack(location, params);
1290 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1294 mGetErrorResult = GL_INVALID_OPERATION;
1298 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1300 std::string params = ToString(v);
1301 AddUniformCallToTraceStack(location, params);
1303 for(int i = 0; i < count; ++i)
1305 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1307 Vector2(v[2 * i], v[2 * i + 1])))
1309 mGetErrorResult = GL_INVALID_OPERATION;
1315 inline void Uniform2i(GLint location, GLint x, GLint y) override
1317 std::string params = ToString(x) + "," + ToString(y);
1318 AddUniformCallToTraceStack(location, params);
1321 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1323 std::string params = ToString(v);
1324 AddUniformCallToTraceStack(location, params);
1327 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1329 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1330 AddUniformCallToTraceStack(location, params);
1332 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1336 mGetErrorResult = GL_INVALID_OPERATION;
1340 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1342 std::string params = ToString(v);
1343 AddUniformCallToTraceStack(location, params);
1345 for(int i = 0; i < count; ++i)
1347 if(!mProgramUniforms3f.SetUniformValue(
1350 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1352 mGetErrorResult = GL_INVALID_OPERATION;
1358 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1360 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1361 AddUniformCallToTraceStack(location, params);
1364 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1366 std::string params = ToString(v);
1367 AddUniformCallToTraceStack(location, params);
1370 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1372 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(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::string params = ToString(v);
1386 AddUniformCallToTraceStack(location, params);
1388 for(int i = 0; i < count; ++i)
1390 if(!mProgramUniforms4f.SetUniformValue(
1393 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1395 mGetErrorResult = GL_INVALID_OPERATION;
1401 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1403 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1404 AddUniformCallToTraceStack(location, params);
1407 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1409 std::string params = ToString(v);
1410 AddUniformCallToTraceStack(location, params);
1413 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1415 std::string params = ToString(value);
1416 AddUniformCallToTraceStack(location, params);
1419 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1421 std::string params = ToString(value);
1422 AddUniformCallToTraceStack(location, params);
1424 for(int i = 0; i < count; ++i)
1426 if(!mProgramUniformsMat3.SetUniformValue(
1429 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1431 mGetErrorResult = GL_INVALID_OPERATION;
1437 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1439 std::string params = ToString(value);
1440 AddUniformCallToTraceStack(location, params);
1442 for(int i = 0; i < count; ++i)
1444 if(!mProgramUniformsMat4.SetUniformValue(
1449 mGetErrorResult = GL_INVALID_OPERATION;
1455 inline void UseProgram(GLuint program) override
1457 mCurrentProgram = program;
1460 inline void ValidateProgram(GLuint program) override
1464 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1468 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1472 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1476 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1480 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1484 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1488 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1492 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1496 inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1500 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1502 std::string commaString(", ");
1503 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1505 mViewportTrace.PushCall("Viewport", params);
1510 inline void ReadBuffer(GLenum mode) override
1514 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1518 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
1522 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
1526 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1530 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1534 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
1538 inline void GenQueries(GLsizei n, GLuint* ids) override
1542 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1546 inline GLboolean IsQuery(GLuint id) override
1551 inline void BeginQuery(GLenum target, GLuint id) override
1555 inline void EndQuery(GLenum target) override
1559 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1563 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1567 inline GLboolean UnmapBuffer(GLenum target) override
1572 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1576 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1580 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1584 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1588 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1592 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1596 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1600 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1604 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1608 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1612 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1616 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1621 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1625 inline void BindVertexArray(GLuint array) override
1629 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1633 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1637 inline GLboolean IsVertexArray(GLuint array) override
1642 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1646 inline void BeginTransformFeedback(GLenum primitiveMode) override
1650 inline void EndTransformFeedback(void) override
1654 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1658 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1662 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1666 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1670 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1674 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1678 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1682 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1686 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1690 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1694 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1698 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1702 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1707 inline void Uniform1ui(GLint location, GLuint v0) override
1711 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1715 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1719 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1723 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1727 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1731 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1735 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1739 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1743 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1747 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1751 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1755 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1760 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1764 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1768 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1772 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1774 return GL_INVALID_INDEX;
1777 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1781 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1785 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1789 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1793 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1797 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1802 inline GLboolean IsSync(GLsync sync) override
1807 inline void DeleteSync(GLsync sync) override
1811 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1816 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1820 inline void GetInteger64v(GLenum pname, GLint64* params) override
1824 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1828 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1832 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1836 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1840 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1844 inline GLboolean IsSampler(GLuint sampler) override
1849 inline void BindSampler(GLuint unit, GLuint sampler) override
1853 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1857 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1861 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1865 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1869 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1873 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1877 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1881 inline void BindTransformFeedback(GLenum target, GLuint id) override
1885 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1889 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1893 inline GLboolean IsTransformFeedback(GLuint id) override
1898 inline void PauseTransformFeedback(void) override
1902 inline void ResumeTransformFeedback(void) override
1906 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1908 mGetProgramBinaryCalled = true;
1911 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1915 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1919 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1923 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1927 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1931 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1935 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1939 inline void BlendBarrier(void)
1944 inline void AddUniformCallToTraceStack(GLint location, std::string& value)
1946 std::string name = "<not found>";
1947 bool matched = false;
1949 UniformIDMap& map = mUniforms[mCurrentProgram];
1950 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1952 if(it->second == location)
1962 mSetUniformTrace.PushCall(name, value);
1966 public: // TEST FUNCTIONS
1967 inline void SetCompileStatus(GLuint value)
1969 mCompileStatus = value;
1971 inline void SetLinkStatus(GLuint value)
1973 mLinkStatus = value;
1975 inline void SetGetAttribLocationResult(int result)
1977 mGetAttribLocationResult = result;
1979 inline void SetGetErrorResult(GLenum result)
1981 mGetErrorResult = result;
1983 inline void SetGetStringResult(GLubyte* result)
1985 mGetStringResult = result;
1987 inline void SetIsBufferResult(GLboolean result)
1989 mIsBufferResult = result;
1991 inline void SetIsEnabledResult(GLboolean result)
1993 mIsEnabledResult = result;
1995 inline void SetIsFramebufferResult(GLboolean result)
1997 mIsFramebufferResult = result;
1999 inline void SetIsProgramResult(GLboolean result)
2001 mIsProgramResult = result;
2003 inline void SetIsRenderbufferResult(GLboolean result)
2005 mIsRenderbufferResult = result;
2007 inline void SetIsShaderResult(GLboolean result)
2009 mIsShaderResult = result;
2011 inline void SetIsTextureResult(GLboolean result)
2013 mIsTextureResult = result;
2015 inline void SetCheckFramebufferStatusResult(GLenum result)
2017 mCheckFramebufferStatusResult = result;
2019 inline void SetNumBinaryFormats(GLint numFormats)
2021 mNumBinaryFormats = numFormats;
2023 inline void SetBinaryFormats(GLint binaryFormats)
2025 mBinaryFormats = binaryFormats;
2027 inline void SetProgramBinaryLength(GLint length)
2029 mProgramBinaryLength = length;
2032 inline bool GetVertexAttribArrayState(GLuint index)
2034 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2039 return mVertexAttribArrayState[index];
2041 inline void ClearVertexAttribArrayChanged()
2043 mVertexAttribArrayChanged = false;
2045 inline bool GetVertexAttribArrayChanged()
2047 return mVertexAttribArrayChanged;
2050 //Methods for CullFace verification
2051 inline void EnableCullFaceCallTrace(bool enable)
2053 mCullFaceTrace.Enable(enable);
2055 inline void ResetCullFaceCallStack()
2057 mCullFaceTrace.Reset();
2059 inline TraceCallStack& GetCullFaceTrace()
2061 return mCullFaceTrace;
2064 //Methods for Enable/Disable call verification
2065 inline void EnableEnableDisableCallTrace(bool enable)
2067 mEnableDisableTrace.Enable(enable);
2069 inline void ResetEnableDisableCallStack()
2071 mEnableDisableTrace.Reset();
2073 inline TraceCallStack& GetEnableDisableTrace()
2075 return mEnableDisableTrace;
2078 //Methods for Shader verification
2079 inline void EnableShaderCallTrace(bool enable)
2081 mShaderTrace.Enable(enable);
2083 inline void ResetShaderCallStack()
2085 mShaderTrace.Reset();
2087 inline TraceCallStack& GetShaderTrace()
2089 return mShaderTrace;
2092 //Methods for Texture verification
2093 inline void EnableTextureCallTrace(bool enable)
2095 mTextureTrace.Enable(enable);
2097 inline void ResetTextureCallStack()
2099 mTextureTrace.Reset();
2101 inline TraceCallStack& GetTextureTrace()
2103 return mTextureTrace;
2106 //Methods for Texture verification
2107 inline void EnableTexParameterCallTrace(bool enable)
2109 mTexParamaterTrace.Enable(enable);
2111 inline void ResetTexParameterCallStack()
2113 mTexParamaterTrace.Reset();
2115 inline TraceCallStack& GetTexParameterTrace()
2117 return mTexParamaterTrace;
2120 //Methods for Draw verification
2121 inline void EnableDrawCallTrace(bool enable)
2123 mDrawTrace.Enable(enable);
2125 inline void ResetDrawCallStack()
2129 inline TraceCallStack& GetDrawTrace()
2134 //Methods for Depth function verification
2135 inline void EnableDepthFunctionCallTrace(bool enable)
2137 mDepthFunctionTrace.Enable(enable);
2139 inline void ResetDepthFunctionCallStack()
2141 mDepthFunctionTrace.Reset();
2143 inline TraceCallStack& GetDepthFunctionTrace()
2145 return mDepthFunctionTrace;
2148 //Methods for Stencil function verification
2149 inline void EnableStencilFunctionCallTrace(bool enable)
2151 mStencilFunctionTrace.Enable(enable);
2153 inline void ResetStencilFunctionCallStack()
2155 mStencilFunctionTrace.Reset();
2157 inline TraceCallStack& GetStencilFunctionTrace()
2159 return mStencilFunctionTrace;
2162 //Methods for Scissor verification
2163 inline void EnableScissorCallTrace(bool enable)
2165 mScissorTrace.Enable(enable);
2167 inline void ResetScissorCallStack()
2169 mScissorTrace.Reset();
2171 inline TraceCallStack& GetScissorTrace()
2173 return mScissorTrace;
2176 //Methods for Uniform function verification
2177 inline void EnableSetUniformCallTrace(bool enable)
2179 mSetUniformTrace.Enable(enable);
2181 inline void ResetSetUniformCallStack()
2183 mSetUniformTrace.Reset();
2185 inline TraceCallStack& GetSetUniformTrace()
2187 return mSetUniformTrace;
2190 //Methods for Viewport verification
2191 inline void EnableViewportCallTrace(bool enable)
2193 mViewportTrace.Enable(enable);
2195 inline void ResetViewportCallStack()
2197 mViewportTrace.Reset();
2199 inline TraceCallStack& GetViewportTrace()
2201 return mViewportTrace;
2203 inline TraceCallStack& GetBufferTrace()
2205 return mBufferTrace;
2208 template<typename T>
2209 inline bool GetUniformValue(const char* name, T& value) const
2211 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2212 program_it != mUniforms.end();
2215 const UniformIDMap& uniformIDs = program_it->second;
2217 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2218 if(uniform_it != uniformIDs.end())
2220 // found one matching uniform name, lets check the value...
2221 GLuint programId = program_it->first;
2222 GLint uniformId = uniform_it->second;
2224 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2225 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2231 template<typename T>
2232 inline bool CheckUniformValue(const char* name, const T& value) const
2234 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2235 program_it != mUniforms.end();
2238 const UniformIDMap& uniformIDs = program_it->second;
2240 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2241 if(uniform_it != uniformIDs.end())
2243 // found one matching uniform name, lets check the value...
2244 GLuint programId = program_it->first;
2245 GLint uniformId = uniform_it->second;
2247 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2248 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2250 // the value matches
2256 fprintf(stderr, "Not found, printing possible values:\n");
2257 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2258 program_it != mUniforms.end();
2261 const UniformIDMap& uniformIDs = program_it->second;
2263 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2264 if(uniform_it != uniformIDs.end())
2266 // found one matching uniform name, lets check the value...
2267 GLuint programId = program_it->first;
2268 GLint uniformId = uniform_it->second;
2270 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2272 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2274 std::stringstream out;
2275 out << uniform_it->first << ": " << origValue;
2276 fprintf(stderr, "%s\n", out.str().c_str());
2283 template<typename T>
2284 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2286 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2287 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2290 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2292 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2293 program_it != mUniforms.end();
2296 const UniformIDMap& uniformIDs = program_it->second;
2298 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2299 if(uniform_it != uniformIDs.end())
2301 programId = program_it->first;
2302 uniformId = uniform_it->second;
2309 inline GLuint GetLastShaderCompiled() const
2311 return mLastShaderCompiled;
2314 inline GLuint GetLastProgramCreated() const
2316 return mLastProgramIdUsed;
2319 inline GLbitfield GetLastClearMask() const
2321 return mLastClearBitMask;
2326 ATTRIB_UNKNOWN = -1,
2331 ATTRIB_BONE_WEIGHTS,
2332 ATTRIB_BONE_INDICES,
2336 struct ScissorParams
2352 // Methods to check scissor tests
2353 inline const ScissorParams& GetScissorParams() const
2355 return mScissorParams;
2358 struct ColorMaskParams
2374 inline bool GetProgramBinaryCalled() const
2376 return mGetProgramBinaryCalled;
2379 inline unsigned int GetClearCountCalled() const
2384 inline const ColorMaskParams& GetColorMaskParams() const
2386 return mColorMaskParams;
2389 typedef std::vector<size_t> BufferDataCalls;
2390 inline const BufferDataCalls& GetBufferDataCalls() const
2392 return mBufferDataCalls;
2394 inline void ResetBufferDataCalls()
2396 mBufferDataCalls.clear();
2399 typedef std::vector<size_t> BufferSubDataCalls;
2400 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2402 return mBufferSubDataCalls;
2404 inline void ResetBufferSubDataCalls()
2406 mBufferSubDataCalls.clear();
2410 GLuint mCurrentProgram;
2411 GLuint mCompileStatus;
2412 BufferDataCalls mBufferDataCalls;
2413 BufferSubDataCalls mBufferSubDataCalls;
2415 GLint mNumberOfActiveUniforms;
2416 GLint mGetAttribLocationResult;
2417 GLenum mGetErrorResult;
2418 GLubyte* mGetStringResult;
2419 GLboolean mIsBufferResult;
2420 GLboolean mIsEnabledResult;
2421 GLboolean mIsFramebufferResult;
2422 GLboolean mIsProgramResult;
2423 GLboolean mIsRenderbufferResult;
2424 GLboolean mIsShaderResult;
2425 GLboolean mIsTextureResult;
2426 GLenum mActiveTextureUnit;
2427 GLenum mCheckFramebufferStatusResult;
2428 GLint mFramebufferStatus;
2429 GLenum mFramebufferDepthAttached;
2430 GLenum mFramebufferStencilAttached;
2431 GLuint mFramebufferColorAttachmentCount;
2432 GLuint mFrameBufferColorStatus;
2433 GLint mNumBinaryFormats;
2434 GLint mBinaryFormats;
2435 GLint mProgramBinaryLength;
2436 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2437 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2438 bool mGetProgramBinaryCalled;
2439 typedef std::map<GLuint, std::string> ShaderSourceMap;
2440 ShaderSourceMap mShaderSources;
2441 GLuint mLastShaderCompiled;
2442 GLbitfield mLastClearBitMask;
2443 Vector4 mLastClearColor;
2444 unsigned int mClearCount;
2446 Vector4 mLastBlendColor;
2447 GLenum mLastBlendEquationRgb;
2448 GLenum mLastBlendEquationAlpha;
2449 GLenum mLastBlendFuncSrcRgb;
2450 GLenum mLastBlendFuncDstRgb;
2451 GLenum mLastBlendFuncSrcAlpha;
2452 GLenum mLastBlendFuncDstAlpha;
2454 GLboolean mLastDepthMask;
2456 // Data for manipulating the IDs returned by GenTextures
2457 GLuint mLastAutoTextureIdUsed;
2458 GLuint mNumGeneratedTextures;
2459 std::vector<GLuint> mNextTextureIds;
2460 std::vector<GLuint> mDeletedTextureIds;
2461 std::vector<GLuint> mBoundTextures;
2463 struct ActiveTextureType
2465 std::vector<GLuint> mBoundTextures;
2468 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2470 TraceCallStack mBufferTrace{"gl"};
2471 TraceCallStack mCullFaceTrace;
2472 TraceCallStack mEnableDisableTrace;
2473 TraceCallStack mShaderTrace;
2474 TraceCallStack mTextureTrace{"gl"};
2475 TraceCallStack mTexParamaterTrace;
2476 TraceCallStack mDrawTrace;
2477 TraceCallStack mDepthFunctionTrace;
2478 TraceCallStack mStencilFunctionTrace;
2479 TraceCallStack mScissorTrace;
2480 TraceCallStack mSetUniformTrace;
2481 TraceCallStack mViewportTrace;
2483 // Shaders & Uniforms
2484 GLuint mLastShaderIdUsed;
2485 GLuint mLastProgramIdUsed;
2486 GLuint mLastUniformIdUsed;
2487 typedef std::map<std::string, GLint> UniformIDMap;
2488 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2489 ProgramUniformMap mUniforms;
2491 template<typename T>
2492 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2495 typedef std::map<GLint, T> UniformValueMap;
2496 typedef std::map<GLuint, UniformValueMap> Map;
2498 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2505 typename Map::iterator it = Map::find(program);
2506 if(it == Map::end())
2508 // if its the first uniform for this program add it
2509 std::pair<typename Map::iterator, bool> result =
2510 Map::insert(typename Map::value_type(program, UniformValueMap()));
2514 UniformValueMap& uniforms = it->second;
2515 uniforms[uniform] = value;
2520 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2523 if(GetUniformValue(program, uniform, uniformValue))
2525 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2531 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2538 typename Map::const_iterator it = Map::find(program);
2539 if(it == Map::end())
2541 // Uniform values always initialised as 0
2546 const UniformValueMap& uniforms = it->second;
2547 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2548 if(it2 == uniforms.end())
2550 // Uniform values always initialised as 0
2554 value = it2->second;
2561 ProgramUniformValue<int> mProgramUniforms1i;
2562 ProgramUniformValue<float> mProgramUniforms1f;
2563 ProgramUniformValue<Vector2> mProgramUniforms2f;
2564 ProgramUniformValue<Vector3> mProgramUniforms3f;
2565 ProgramUniformValue<Vector4> mProgramUniforms4f;
2566 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2567 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2569 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2571 return mProgramUniforms1i;
2573 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2575 return mProgramUniforms1f;
2577 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2579 return mProgramUniforms2f;
2581 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2583 return mProgramUniforms3f;
2585 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2587 return mProgramUniforms4f;
2589 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2591 return mProgramUniformsMat4;
2593 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2595 return mProgramUniformsMat3;
2597 inline void SetVertexAttribArray(GLuint index, bool state)
2599 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2604 mVertexAttribArrayState[index] = state;
2605 mVertexAttribArrayChanged = true;
2608 ScissorParams mScissorParams;
2609 ColorMaskParams mColorMaskParams;
2613 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2619 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2625 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2627 return Vector2::ZERO;
2631 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2633 return Vector3::ZERO;
2637 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2639 return Vector4::ZERO;
2643 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2649 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2651 return Matrix3(Matrix());
2656 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2657 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2659 #endif // TEST_GL_ABSTRACTION_H