1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
24 #include <cstring> // for strcmp
31 #include <dali/devel-api/rendering/frame-buffer-devel.h>
32 #include <dali/integration-api/core.h>
33 #include <dali/integration-api/gl-abstraction.h>
34 #include <dali/integration-api/gl-defines.h>
35 #include <dali/public-api/dali-core.h>
36 #include <test-compare-types.h>
37 #include <test-trace-call-stack.h>
41 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
44 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
47 ~TestGlAbstraction() override;
50 void PreRender() override;
51 void PostRender() override;
53 bool IsSurfacelessContextSupported() const override;
55 bool IsAdvancedBlendEquationSupported() override;
57 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
59 std::string GetShaderVersionPrefix();
61 std::string GetVertexShaderPrefix();
63 std::string GetFragmentShaderPrefix();
65 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
69 inline void ActiveTexture(GLenum textureUnit) override
71 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
74 inline GLenum GetActiveTextureUnit() const
76 return mActiveTextureUnit + GL_TEXTURE0;
79 inline void AttachShader(GLuint program, GLuint shader) override
81 std::stringstream out;
82 out << program << ", " << shader;
84 TraceCallStack::NamedParams namedParams;
85 namedParams["program"] << program;
86 namedParams["shader"] << shader;
87 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
90 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
94 inline void BindBuffer(GLenum target, GLuint buffer) override
97 o << std::hex << target << ", " << buffer;
98 TraceCallStack::NamedParams namedParams;
99 namedParams["target"] << target;
100 namedParams["buffer"] << buffer;
101 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
104 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
107 mFramebufferStatus |= 2;
110 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
115 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
116 * @return A vector containing the IDs that were bound.
118 inline const std::vector<GLuint>& GetBoundTextures() const
120 return mBoundTextures;
124 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
125 * @param[in] activeTextureUnit The specific active texture unit.
126 * @return A vector containing the IDs that were bound.
128 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
130 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
134 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
136 inline void ClearBoundTextures()
138 mBoundTextures.clear();
140 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
142 mActiveTextures[i].mBoundTextures.clear();
146 inline void BindTexture(GLenum target, GLuint texture) override
148 // Record the bound textures for future checks
151 mBoundTextures.push_back(texture);
153 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
155 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
159 std::stringstream out;
160 out << target << ", " << texture;
162 TraceCallStack::NamedParams namedParams;
163 namedParams["target"] << target;
164 namedParams["texture"] << texture;
166 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
169 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
171 mLastBlendColor.r = red;
172 mLastBlendColor.g = green;
173 mLastBlendColor.b = blue;
174 mLastBlendColor.a = alpha;
177 inline const Vector4& GetLastBlendColor() const
179 return mLastBlendColor;
182 inline void BlendEquation(GLenum mode) override
184 mLastBlendEquationRgb = mode;
185 mLastBlendEquationAlpha = mode;
188 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
190 mLastBlendEquationRgb = modeRgb;
191 mLastBlendEquationAlpha = modeAlpha;
194 inline GLenum GetLastBlendEquationRgb() const
196 return mLastBlendEquationRgb;
199 inline GLenum GetLastBlendEquationAlpha() const
201 return mLastBlendEquationAlpha;
204 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
206 mLastBlendFuncSrcRgb = sfactor;
207 mLastBlendFuncDstRgb = dfactor;
208 mLastBlendFuncSrcAlpha = sfactor;
209 mLastBlendFuncDstAlpha = dfactor;
212 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
214 mLastBlendFuncSrcRgb = srcRGB;
215 mLastBlendFuncDstRgb = dstRGB;
216 mLastBlendFuncSrcAlpha = srcAlpha;
217 mLastBlendFuncDstAlpha = dstAlpha;
220 inline GLenum GetLastBlendFuncSrcRgb() const
222 return mLastBlendFuncSrcRgb;
225 inline GLenum GetLastBlendFuncDstRgb() const
227 return mLastBlendFuncDstRgb;
230 inline GLenum GetLastBlendFuncSrcAlpha() const
232 return mLastBlendFuncSrcAlpha;
235 inline GLenum GetLastBlendFuncDstAlpha() const
237 return mLastBlendFuncDstAlpha;
240 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
242 std::ostringstream o;
243 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
244 TraceCallStack::NamedParams namedParams;
245 namedParams["target"] << std::hex << target;
246 namedParams["size"] << size;
247 namedParams["usage"] << usage;
249 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
251 mBufferDataCalls.push_back(size);
254 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
256 std::ostringstream o;
257 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
258 TraceCallStack::NamedParams namedParams;
259 namedParams["target"] << std::hex << target;
260 namedParams["offset"] << offset;
261 namedParams["size"] << size;
262 mBufferTrace.PushCall("BufferSubData", o.str());
264 mBufferSubDataCalls.push_back(size);
267 inline GLenum CheckFramebufferStatus(GLenum target) override
269 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
270 //Framebuffer texture have been called
271 if(mFramebufferStatus == 7)
273 return GL_FRAMEBUFFER_COMPLETE;
276 return mCheckFramebufferStatusResult;
279 inline GLuint CheckFramebufferColorAttachmentCount()
281 return mFramebufferColorAttachmentCount;
284 inline GLenum CheckFramebufferDepthAttachment()
286 return mFramebufferDepthAttached;
289 inline GLenum CheckFramebufferStencilAttachment()
291 return mFramebufferStencilAttached;
294 inline void Clear(GLbitfield mask) override
297 mLastClearBitMask = mask;
300 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
302 mLastClearColor.r = red;
303 mLastClearColor.g = green;
304 mLastClearColor.b = blue;
305 mLastClearColor.a = alpha;
308 inline const Vector4& GetLastClearColor() const
310 return mLastClearColor;
313 inline void ClearDepthf(GLclampf depth) override
317 inline void ClearStencil(GLint s) override
319 std::stringstream out;
322 TraceCallStack::NamedParams namedParams;
323 namedParams["s"] << s;
325 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
328 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
330 mColorMaskParams.red = red;
331 mColorMaskParams.green = green;
332 mColorMaskParams.blue = blue;
333 mColorMaskParams.alpha = alpha;
336 inline void CompileShader(GLuint shader) override
338 std::stringstream out;
340 TraceCallStack::NamedParams namedParams;
341 namedParams["shader"] << shader;
343 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
346 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
348 std::stringstream out;
349 out << target << ", " << level << ", " << width << ", " << height;
351 TraceCallStack::NamedParams namedParams;
352 namedParams["target"] << std::hex << target;
353 namedParams["level"] << level;
354 namedParams["internalformat"] << internalformat;
355 namedParams["width"] << width;
356 namedParams["height"] << height;
357 namedParams["border"] << border;
358 namedParams["size"] << imageSize;
360 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
363 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
365 std::stringstream out;
366 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
368 TraceCallStack::NamedParams namedParams;
369 namedParams["target"] << std::hex << target;
370 namedParams["level"] << level;
371 namedParams["xoffset"] << xoffset;
372 namedParams["yoffset"] << yoffset;
373 namedParams["width"] << width;
374 namedParams["height"] << height;
375 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
378 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
382 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
386 inline GLuint CreateProgram(void) override
388 mShaderTrace.PushCall("CreateProgram", "");
390 ++mLastProgramIdUsed;
391 mUniforms[mLastProgramIdUsed] = UniformIDMap();
392 return mLastProgramIdUsed;
395 inline GLuint CreateShader(GLenum type) override
397 std::stringstream out;
400 TraceCallStack::NamedParams namedParams;
401 namedParams["type"] << std::hex << type;
402 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
404 return ++mLastShaderIdUsed;
407 inline void CullFace(GLenum mode) override
409 std::stringstream out;
412 TraceCallStack::NamedParams namedParams;
413 namedParams["program"] << 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;
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;
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;
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
636 inline void GenBuffers(GLsizei n, GLuint* buffers) override
638 // avoids an assert in GpuBuffers
641 std::ostringstream o;
643 TraceCallStack::NamedParams namedParams;
644 namedParams["n"] << o.str();
645 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
648 inline void GenerateMipmap(GLenum target) override
650 std::stringstream out;
652 TraceCallStack::NamedParams namedParams;
653 namedParams["target"] << std::hex << target;
655 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
658 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
660 for(int i = 0; i < n; i++)
662 framebuffers[i] = i + 1;
665 //Add 001 bit, this function needs to be called the first one in the chain
666 mFramebufferStatus = 1;
669 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
671 for(int i = 0; i < n; i++)
673 renderbuffers[i] = i + 1;
678 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
679 * @param[in] ids A vector containing the next IDs to be generated
681 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
683 mNextTextureIds = ids;
686 inline const std::vector<GLuint>& GetNextTextureIds()
688 return mNextTextureIds;
691 inline void GenTextures(GLsizei count, GLuint* textures) override
693 for(int i = 0; i < count; ++i)
695 if(!mNextTextureIds.empty())
697 *(textures + i) = mNextTextureIds[0];
698 mNextTextureIds.erase(mNextTextureIds.begin());
702 *(textures + i) = ++mLastAutoTextureIdUsed;
704 mNumGeneratedTextures++;
707 TraceCallStack::NamedParams namedParams;
708 namedParams["count"] << count;
710 std::stringstream out;
711 for(int i = 0; i < count; i++)
718 std::ostringstream oss;
719 oss << "indices[" << i << "]";
720 namedParams[oss.str()] << textures[i];
723 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
726 inline GLuint GetLastGenTextureId()
728 return mLastAutoTextureIdUsed;
731 inline GLuint GetNumGeneratedTextures()
733 return mNumGeneratedTextures;
736 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
740 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
745 *length = snprintf(name, bufsize, "sTexture");
746 *type = GL_SAMPLER_2D;
750 *length = snprintf(name, bufsize, "sEffect");
751 *type = GL_SAMPLER_2D;
755 *length = snprintf(name, bufsize, "sGloss");
756 *type = GL_SAMPLER_2D;
764 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
768 inline int GetAttribLocation(GLuint program, const char* name) override
770 std::string check(name);
771 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
772 if(iter == mAttribLocs.end())
774 return iter - mAttribLocs.begin();
777 inline void GetBooleanv(GLenum pname, GLboolean* params) override
781 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
785 inline GLenum GetError(void) override
787 return mGetErrorResult;
790 inline void GetFloatv(GLenum pname, GLfloat* params) override
794 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
798 inline void GetIntegerv(GLenum pname, GLint* params) override
802 case GL_MAX_TEXTURE_SIZE:
805 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
808 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
809 *params = mNumBinaryFormats;
811 case GL_PROGRAM_BINARY_FORMATS_OES:
812 *params = mBinaryFormats;
817 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
822 *params = mLinkStatus;
824 case GL_PROGRAM_BINARY_LENGTH_OES:
825 *params = mProgramBinaryLength;
827 case GL_ACTIVE_UNIFORMS:
828 *params = mNumberOfActiveUniforms;
830 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
836 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
840 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
844 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
848 case GL_COMPILE_STATUS:
849 *params = mCompileStatus;
854 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
858 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
862 inline const GLubyte* GetString(GLenum name) override
864 return mGetStringResult;
867 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
871 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
875 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
879 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
883 inline GLint GetUniformLocation(GLuint program, const char* name) override
885 ProgramUniformMap::iterator it = mUniforms.find(program);
886 if(it == mUniforms.end())
888 // Not a valid program ID
889 mGetErrorResult = GL_INVALID_OPERATION;
893 UniformIDMap& uniformIDs = it->second;
894 UniformIDMap::iterator it2 = uniformIDs.find(name);
895 if(it2 == uniformIDs.end())
897 // Uniform not found, so add it...
898 uniformIDs[name] = ++mLastUniformIdUsed;
899 return mLastUniformIdUsed;
905 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
909 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
913 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
917 inline void Hint(GLenum target, GLenum mode) override
921 inline GLboolean IsBuffer(GLuint buffer) override
923 return mIsBufferResult;
926 inline GLboolean IsEnabled(GLenum cap) override
928 return mIsEnabledResult;
931 inline GLboolean IsFramebuffer(GLuint framebuffer) override
933 return mIsFramebufferResult;
936 inline GLboolean IsProgram(GLuint program) override
938 return mIsProgramResult;
941 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
943 return mIsRenderbufferResult;
946 inline GLboolean IsShader(GLuint shader) override
948 return mIsShaderResult;
951 inline GLboolean IsTexture(GLuint texture) override
953 return mIsTextureResult;
956 inline void LineWidth(GLfloat width) override
960 inline void LinkProgram(GLuint program) override
962 std::stringstream out;
965 TraceCallStack::NamedParams namedParams;
966 namedParams["program"] << program;
967 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
969 mNumberOfActiveUniforms = 3;
970 GetUniformLocation(program, "sTexture");
971 GetUniformLocation(program, "sEffect");
972 GetUniformLocation(program, "sGloss");
975 inline void PixelStorei(GLenum pname, GLint param) override
979 inline void PolygonOffset(GLfloat factor, GLfloat units) override
983 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
987 inline void ReleaseShaderCompiler(void) override
991 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
995 inline void SampleCoverage(GLclampf value, GLboolean invert) override
999 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1001 mScissorParams.x = x;
1002 mScissorParams.y = y;
1003 mScissorParams.width = width;
1004 mScissorParams.height = height;
1006 std::stringstream out;
1007 out << x << ", " << y << ", " << width << ", " << height;
1008 TraceCallStack::NamedParams namedParams;
1009 namedParams["x"] << x;
1010 namedParams["y"] << y;
1011 namedParams["width"] << width;
1012 namedParams["height"] << height;
1013 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1016 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1020 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1022 std::string stringBuilder;
1023 for(int i = 0; i < count; ++i)
1025 stringBuilder += string[i];
1027 mShaderSources[shader] = stringBuilder;
1028 mLastShaderCompiled = shader;
1031 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1033 const std::string shaderSource = mShaderSources[shader];
1034 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1035 if(shaderSourceLength < bufsize)
1037 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1038 *length = shaderSourceLength;
1042 *length = bufsize - 1;
1043 strncpy(source, shaderSource.c_str(), *length);
1044 source[*length] = 0x0;
1048 inline std::string GetShaderSource(GLuint shader)
1050 return mShaderSources[shader];
1053 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1055 std::stringstream out;
1056 out << func << ", " << ref << ", " << mask;
1058 TraceCallStack::NamedParams namedParams;
1059 namedParams["func"] << std::hex << func;
1060 namedParams["ref"] << ref;
1061 namedParams["mask"] << mask;
1063 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1066 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1068 std::stringstream out;
1069 out << face << ", " << func << ", " << ref << ", " << mask;
1071 TraceCallStack::NamedParams namedParams;
1072 namedParams["face"] << std::hex << face;
1073 namedParams["func"] << std::hex << func;
1074 namedParams["ref"] << ref;
1075 namedParams["mask"] << mask;
1077 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1080 inline void StencilMask(GLuint mask) override
1082 std::stringstream out;
1085 TraceCallStack::NamedParams namedParams;
1086 namedParams["mask"] << mask;
1088 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1091 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1093 std::stringstream out;
1094 out << face << ", " << mask;
1096 TraceCallStack::NamedParams namedParams;
1097 namedParams["face"] << std::hex << face;
1098 namedParams["mask"] << mask;
1100 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1103 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1105 std::stringstream out;
1106 out << fail << ", " << zfail << ", " << zpass;
1108 TraceCallStack::NamedParams namedParams;
1109 namedParams["fail"] << std::hex << fail;
1110 namedParams["zfail"] << std::hex << zfail;
1111 namedParams["zpass"] << std::hex << zpass;
1113 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1116 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1118 std::stringstream out;
1119 out << face << ", " << fail << ", " << zfail << "," << zpass;
1121 TraceCallStack::NamedParams namedParams;
1122 namedParams["face"] << std::hex << face;
1123 namedParams["fail"] << std::hex << fail;
1124 namedParams["zfail"] << std::hex << zfail;
1125 namedParams["zpass"] << std::hex << zpass;
1127 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1130 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1132 std::stringstream out;
1133 out << target << ", " << level << ", " << width << ", " << height;
1135 TraceCallStack::NamedParams namedParams;
1136 namedParams["target"] << std::hex << target;
1137 namedParams["level"] << level;
1138 namedParams["internalformat"] << internalformat;
1139 namedParams["width"] << width;
1140 namedParams["height"] << height;
1141 namedParams["border"] << border;
1142 namedParams["format"] << std::hex << format;
1143 namedParams["type"] << std::hex << type;
1145 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1148 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1150 std::stringstream out;
1151 out << target << ", " << pname << ", " << param;
1153 TraceCallStack::NamedParams namedParams;
1154 namedParams["target"] << std::hex << target;
1155 namedParams["pname"] << std::hex << pname;
1156 namedParams["param"] << param;
1158 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1161 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1163 std::stringstream out;
1164 out << target << ", " << pname << ", " << params[0];
1166 TraceCallStack::NamedParams namedParams;
1167 namedParams["target"] << std::hex << target;
1168 namedParams["pname"] << std::hex << pname;
1169 namedParams["params[0]"] << params[0];
1171 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1174 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1176 std::stringstream out;
1177 out << std::hex << target << ", " << pname << ", " << param;
1178 std::string params = out.str();
1181 out << std::hex << target;
1182 TraceCallStack::NamedParams namedParams;
1183 namedParams["target"] << out.str();
1185 out << std::hex << pname;
1186 namedParams["pname"] << out.str();
1188 out << std::hex << param;
1189 namedParams["param"] << out.str();
1190 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1193 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1195 std::stringstream out;
1196 out << target << ", " << pname << ", " << params[0];
1197 TraceCallStack::NamedParams namedParams;
1198 namedParams["target"] << std::hex << target;
1199 namedParams["pname"] << std::hex << pname;
1200 namedParams["params[0]"] << params[0];
1201 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1204 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1206 std::stringstream out;
1207 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1209 TraceCallStack::NamedParams namedParams;
1210 namedParams["target"] << std::hex << target;
1211 namedParams["level"] << level;
1212 namedParams["xoffset"] << xoffset;
1213 namedParams["yoffset"] << yoffset;
1214 namedParams["width"] << width;
1215 namedParams["height"] << height;
1216 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1219 inline void Uniform1f(GLint location, GLfloat value) override
1221 std::string params = std::to_string(value);
1222 AddUniformCallToTraceStack(location, params);
1224 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1226 mGetErrorResult = GL_INVALID_OPERATION;
1230 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1233 for(int i = 0; i < count; ++i)
1235 params = params + std::to_string(v[i]) + ",";
1238 AddUniformCallToTraceStack(location, params);
1240 for(int i = 0; i < count; ++i)
1242 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1244 mGetErrorResult = GL_INVALID_OPERATION;
1250 inline void Uniform1i(GLint location, GLint x) override
1252 std::string params = std::to_string(x);
1254 AddUniformCallToTraceStack(location, params);
1256 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1258 mGetErrorResult = GL_INVALID_OPERATION;
1262 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1264 std::ostringstream out;
1265 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1266 AddUniformCallToTraceStack(location, out.str());
1268 for(int i = 0; i < count; ++i)
1270 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1274 mGetErrorResult = GL_INVALID_OPERATION;
1280 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1282 std::string params = std::to_string(x) + "," + std::to_string(y);
1283 AddUniformCallToTraceStack(location, params);
1285 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1289 mGetErrorResult = GL_INVALID_OPERATION;
1293 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1295 std::ostringstream out;
1296 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1297 AddUniformCallToTraceStack(location, out.str());
1299 for(int i = 0; i < count; ++i)
1301 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1303 Vector2(v[2 * i], v[2 * i + 1])))
1305 mGetErrorResult = GL_INVALID_OPERATION;
1311 inline void Uniform2i(GLint location, GLint x, GLint y) override
1313 std::string params = std::to_string(x) + "," + std::to_string(y);
1314 AddUniformCallToTraceStack(location, params);
1317 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1319 std::ostringstream out;
1320 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1321 AddUniformCallToTraceStack(location, out.str());
1324 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1326 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1327 AddUniformCallToTraceStack(location, params);
1329 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1333 mGetErrorResult = GL_INVALID_OPERATION;
1337 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1339 std::ostringstream out;
1340 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1341 AddUniformCallToTraceStack(location, out.str());
1343 for(int i = 0; i < count; ++i)
1345 if(!mProgramUniforms3f.SetUniformValue(
1348 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1350 mGetErrorResult = GL_INVALID_OPERATION;
1356 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1358 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1359 AddUniformCallToTraceStack(location, params);
1362 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1364 std::ostringstream out;
1365 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1366 AddUniformCallToTraceStack(location, out.str());
1369 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1371 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1372 AddUniformCallToTraceStack(location, params);
1374 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1376 Vector4(x, y, z, w)))
1378 mGetErrorResult = GL_INVALID_OPERATION;
1382 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1384 std::ostringstream out;
1385 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1386 AddUniformCallToTraceStack(location, out.str());
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 = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1404 AddUniformCallToTraceStack(location, params);
1407 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1409 std::ostringstream out;
1410 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1411 AddUniformCallToTraceStack(location, out.str());
1414 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1416 std::ostringstream out;
1417 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1418 AddUniformCallToTraceStack(location, out.str());
1421 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1423 std::ostringstream out;
1424 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1425 AddUniformCallToTraceStack(location, out.str());
1427 for(int i = 0; i < count; ++i)
1429 if(!mProgramUniformsMat3.SetUniformValue(
1432 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1434 mGetErrorResult = GL_INVALID_OPERATION;
1440 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1442 std::ostringstream out;
1443 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1444 AddUniformCallToTraceStack(location, out.str());
1446 for(int i = 0; i < count; ++i)
1448 if(!mProgramUniformsMat4.SetUniformValue(
1453 mGetErrorResult = GL_INVALID_OPERATION;
1459 inline void UseProgram(GLuint program) override
1461 mCurrentProgram = program;
1464 inline void ValidateProgram(GLuint program) override
1468 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1472 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1476 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1480 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1484 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1488 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1492 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1496 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1500 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1502 TraceCallStack::NamedParams namedParams;
1503 namedParams["index"] << index;
1504 namedParams["size"] << size;
1505 namedParams["type"] << std::hex << type;
1506 namedParams["normalized"] << (normalized ? "T" : "F");
1507 namedParams["stride"] << stride;
1508 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1510 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1513 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1515 std::string commaString(", ");
1516 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1518 mViewportTrace.PushCall("Viewport", params);
1523 inline void ReadBuffer(GLenum mode) override
1527 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1531 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
1535 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
1539 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1543 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1547 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
1551 inline void GenQueries(GLsizei n, GLuint* ids) override
1555 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1559 inline GLboolean IsQuery(GLuint id) override
1564 inline void BeginQuery(GLenum target, GLuint id) override
1568 inline void EndQuery(GLenum target) override
1572 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1576 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1580 inline GLboolean UnmapBuffer(GLenum target) override
1585 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1589 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1593 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1597 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1601 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1605 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1609 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1613 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1617 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1621 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1625 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1629 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1634 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1638 inline void BindVertexArray(GLuint array) override
1642 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1646 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1650 inline GLboolean IsVertexArray(GLuint array) override
1655 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1659 inline void BeginTransformFeedback(GLenum primitiveMode) override
1663 inline void EndTransformFeedback(void) override
1667 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1671 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1675 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1679 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1683 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1687 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1691 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1695 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1699 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1703 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1707 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1711 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1715 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1720 inline void Uniform1ui(GLint location, GLuint v0) override
1724 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1728 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1732 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1736 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1740 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1744 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1748 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1752 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1756 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1760 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1764 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1768 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1773 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1777 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1781 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1785 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1787 return GL_INVALID_INDEX;
1790 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1794 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1798 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1802 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1806 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1810 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1815 inline GLboolean IsSync(GLsync sync) override
1820 inline void DeleteSync(GLsync sync) override
1824 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1829 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1833 inline void GetInteger64v(GLenum pname, GLint64* params) override
1837 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1841 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1845 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1849 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1853 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1857 inline GLboolean IsSampler(GLuint sampler) override
1862 inline void BindSampler(GLuint unit, GLuint sampler) override
1866 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1870 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1874 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1878 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1882 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1886 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1890 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1894 inline void BindTransformFeedback(GLenum target, GLuint id) override
1898 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1902 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1906 inline GLboolean IsTransformFeedback(GLuint id) override
1911 inline void PauseTransformFeedback(void) override
1915 inline void ResumeTransformFeedback(void) override
1919 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1921 mGetProgramBinaryCalled = true;
1924 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1928 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1932 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1936 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1940 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1944 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1948 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1952 inline void BlendBarrier(void)
1957 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
1959 std::string name = "<not found>";
1960 bool matched = false;
1962 UniformIDMap& map = mUniforms[mCurrentProgram];
1963 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1965 if(it->second == location)
1975 mSetUniformTrace.PushCall(name, value);
1979 public: // TEST FUNCTIONS
1980 inline void SetCompileStatus(GLuint value)
1982 mCompileStatus = value;
1984 inline void SetLinkStatus(GLuint value)
1986 mLinkStatus = value;
1988 inline void SetAttribLocations(std::vector<std::string> locs)
1992 inline void SetGetErrorResult(GLenum result)
1994 mGetErrorResult = result;
1996 inline void SetGetStringResult(GLubyte* result)
1998 mGetStringResult = result;
2000 inline void SetIsBufferResult(GLboolean result)
2002 mIsBufferResult = result;
2004 inline void SetIsEnabledResult(GLboolean result)
2006 mIsEnabledResult = result;
2008 inline void SetIsFramebufferResult(GLboolean result)
2010 mIsFramebufferResult = result;
2012 inline void SetIsProgramResult(GLboolean result)
2014 mIsProgramResult = result;
2016 inline void SetIsRenderbufferResult(GLboolean result)
2018 mIsRenderbufferResult = result;
2020 inline void SetIsShaderResult(GLboolean result)
2022 mIsShaderResult = result;
2024 inline void SetIsTextureResult(GLboolean result)
2026 mIsTextureResult = result;
2028 inline void SetCheckFramebufferStatusResult(GLenum result)
2030 mCheckFramebufferStatusResult = result;
2032 inline void SetNumBinaryFormats(GLint numFormats)
2034 mNumBinaryFormats = numFormats;
2036 inline void SetBinaryFormats(GLint binaryFormats)
2038 mBinaryFormats = binaryFormats;
2040 inline void SetProgramBinaryLength(GLint length)
2042 mProgramBinaryLength = length;
2045 inline bool GetVertexAttribArrayState(GLuint index)
2047 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2052 return mVertexAttribArrayState[index];
2054 inline void ClearVertexAttribArrayChanged()
2056 mVertexAttribArrayChanged = false;
2058 inline bool GetVertexAttribArrayChanged()
2060 return mVertexAttribArrayChanged;
2063 //Methods for CullFace verification
2064 inline void EnableCullFaceCallTrace(bool enable)
2066 mCullFaceTrace.Enable(enable);
2068 inline void ResetCullFaceCallStack()
2070 mCullFaceTrace.Reset();
2072 inline TraceCallStack& GetCullFaceTrace()
2074 return mCullFaceTrace;
2077 //Methods for Enable/Disable call verification
2078 inline void EnableEnableDisableCallTrace(bool enable)
2080 mEnableDisableTrace.Enable(enable);
2082 inline void ResetEnableDisableCallStack()
2084 mEnableDisableTrace.Reset();
2086 inline TraceCallStack& GetEnableDisableTrace()
2088 return mEnableDisableTrace;
2091 //Methods for Shader verification
2092 inline void EnableShaderCallTrace(bool enable)
2094 mShaderTrace.Enable(enable);
2096 inline void ResetShaderCallStack()
2098 mShaderTrace.Reset();
2100 inline TraceCallStack& GetShaderTrace()
2102 return mShaderTrace;
2105 //Methods for Texture verification
2106 inline void EnableTextureCallTrace(bool enable)
2108 mTextureTrace.Enable(enable);
2110 inline void ResetTextureCallStack()
2112 mTextureTrace.Reset();
2114 inline TraceCallStack& GetTextureTrace()
2116 return mTextureTrace;
2119 //Methods for Texture verification
2120 inline void EnableTexParameterCallTrace(bool enable)
2122 mTexParameterTrace.Enable(enable);
2124 inline void ResetTexParameterCallStack()
2126 mTexParameterTrace.Reset();
2128 inline TraceCallStack& GetTexParameterTrace()
2130 return mTexParameterTrace;
2133 //Methods for Draw verification
2134 inline void EnableDrawCallTrace(bool enable)
2136 mDrawTrace.Enable(enable);
2138 inline void ResetDrawCallStack()
2142 inline TraceCallStack& GetDrawTrace()
2147 //Methods for Depth function verification
2148 inline void EnableDepthFunctionCallTrace(bool enable)
2150 mDepthFunctionTrace.Enable(enable);
2152 inline void ResetDepthFunctionCallStack()
2154 mDepthFunctionTrace.Reset();
2156 inline TraceCallStack& GetDepthFunctionTrace()
2158 return mDepthFunctionTrace;
2161 //Methods for Stencil function verification
2162 inline void EnableStencilFunctionCallTrace(bool enable)
2164 mStencilFunctionTrace.Enable(enable);
2166 inline void ResetStencilFunctionCallStack()
2168 mStencilFunctionTrace.Reset();
2170 inline TraceCallStack& GetStencilFunctionTrace()
2172 return mStencilFunctionTrace;
2175 //Methods for Scissor verification
2176 inline void EnableScissorCallTrace(bool enable)
2178 mScissorTrace.Enable(enable);
2180 inline void ResetScissorCallStack()
2182 mScissorTrace.Reset();
2184 inline TraceCallStack& GetScissorTrace()
2186 return mScissorTrace;
2189 //Methods for Uniform function verification
2190 inline void EnableSetUniformCallTrace(bool enable)
2192 mSetUniformTrace.Enable(enable);
2194 inline void ResetSetUniformCallStack()
2196 mSetUniformTrace.Reset();
2198 inline TraceCallStack& GetSetUniformTrace()
2200 return mSetUniformTrace;
2203 //Methods for Viewport verification
2204 inline void EnableViewportCallTrace(bool enable)
2206 mViewportTrace.Enable(enable);
2208 inline void ResetViewportCallStack()
2210 mViewportTrace.Reset();
2212 inline TraceCallStack& GetViewportTrace()
2214 return mViewportTrace;
2216 inline TraceCallStack& GetBufferTrace()
2218 return mBufferTrace;
2221 template<typename T>
2222 inline bool GetUniformValue(const char* name, T& value) const
2224 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2225 program_it != mUniforms.end();
2228 const UniformIDMap& uniformIDs = program_it->second;
2230 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2231 if(uniform_it != uniformIDs.end())
2233 // found one matching uniform name, lets check the value...
2234 GLuint programId = program_it->first;
2235 GLint uniformId = uniform_it->second;
2237 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2238 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2244 template<typename T>
2245 inline bool CheckUniformValue(const char* name, const T& value) const
2247 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2248 program_it != mUniforms.end();
2251 const UniformIDMap& uniformIDs = program_it->second;
2253 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2254 if(uniform_it != uniformIDs.end())
2256 // found one matching uniform name, lets check the value...
2257 GLuint programId = program_it->first;
2258 GLint uniformId = uniform_it->second;
2260 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2261 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2263 // the value matches
2269 fprintf(stderr, "Not found, printing possible values:\n");
2270 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2271 program_it != mUniforms.end();
2274 const UniformIDMap& uniformIDs = program_it->second;
2276 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2277 if(uniform_it != uniformIDs.end())
2279 // found one matching uniform name, lets check the value...
2280 GLuint programId = program_it->first;
2281 GLint uniformId = uniform_it->second;
2283 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2285 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2287 std::stringstream out;
2288 out << uniform_it->first << ": " << origValue;
2289 fprintf(stderr, "%s\n", out.str().c_str());
2296 template<typename T>
2297 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2299 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2300 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2303 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2305 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2306 program_it != mUniforms.end();
2309 const UniformIDMap& uniformIDs = program_it->second;
2311 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2312 if(uniform_it != uniformIDs.end())
2314 programId = program_it->first;
2315 uniformId = uniform_it->second;
2322 inline GLuint GetLastShaderCompiled() const
2324 return mLastShaderCompiled;
2327 inline GLuint GetLastProgramCreated() const
2329 return mLastProgramIdUsed;
2332 inline GLbitfield GetLastClearMask() const
2334 return mLastClearBitMask;
2339 ATTRIB_UNKNOWN = -1,
2344 ATTRIB_BONE_WEIGHTS,
2345 ATTRIB_BONE_INDICES,
2349 struct ScissorParams
2365 // Methods to check scissor tests
2366 inline const ScissorParams& GetScissorParams() const
2368 return mScissorParams;
2371 struct ColorMaskParams
2387 inline bool GetProgramBinaryCalled() const
2389 return mGetProgramBinaryCalled;
2392 inline unsigned int GetClearCountCalled() const
2397 inline const ColorMaskParams& GetColorMaskParams() const
2399 return mColorMaskParams;
2402 typedef std::vector<size_t> BufferDataCalls;
2403 inline const BufferDataCalls& GetBufferDataCalls() const
2405 return mBufferDataCalls;
2407 inline void ResetBufferDataCalls()
2409 mBufferDataCalls.clear();
2412 typedef std::vector<size_t> BufferSubDataCalls;
2413 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2415 return mBufferSubDataCalls;
2417 inline void ResetBufferSubDataCalls()
2419 mBufferSubDataCalls.clear();
2423 GLuint mCurrentProgram;
2424 GLuint mCompileStatus;
2425 BufferDataCalls mBufferDataCalls;
2426 BufferSubDataCalls mBufferSubDataCalls;
2428 GLint mNumberOfActiveUniforms;
2429 GLenum mGetErrorResult;
2430 GLubyte* mGetStringResult;
2431 GLboolean mIsBufferResult;
2432 GLboolean mIsEnabledResult;
2433 GLboolean mIsFramebufferResult;
2434 GLboolean mIsProgramResult;
2435 GLboolean mIsRenderbufferResult;
2436 GLboolean mIsShaderResult;
2437 GLboolean mIsTextureResult;
2438 GLenum mActiveTextureUnit;
2439 GLenum mCheckFramebufferStatusResult;
2440 GLint mFramebufferStatus;
2441 GLenum mFramebufferDepthAttached;
2442 GLenum mFramebufferStencilAttached;
2443 GLuint mFramebufferColorAttachmentCount;
2444 GLuint mFrameBufferColorStatus;
2445 GLint mNumBinaryFormats;
2446 GLint mBinaryFormats;
2447 GLint mProgramBinaryLength;
2448 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2449 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2450 bool mGetProgramBinaryCalled;
2451 typedef std::map<GLuint, std::string> ShaderSourceMap;
2452 ShaderSourceMap mShaderSources;
2453 std::vector<std::string> mAttribLocs; // should be bound to shader
2454 GLuint mLastShaderCompiled;
2455 GLbitfield mLastClearBitMask;
2456 Vector4 mLastClearColor;
2457 unsigned int mClearCount;
2459 Vector4 mLastBlendColor;
2460 GLenum mLastBlendEquationRgb;
2461 GLenum mLastBlendEquationAlpha;
2462 GLenum mLastBlendFuncSrcRgb;
2463 GLenum mLastBlendFuncDstRgb;
2464 GLenum mLastBlendFuncSrcAlpha;
2465 GLenum mLastBlendFuncDstAlpha;
2467 GLboolean mLastDepthMask;
2469 // Data for manipulating the IDs returned by GenTextures
2470 GLuint mLastAutoTextureIdUsed;
2471 GLuint mNumGeneratedTextures;
2472 std::vector<GLuint> mNextTextureIds;
2473 std::vector<GLuint> mDeletedTextureIds;
2474 std::vector<GLuint> mBoundTextures;
2476 struct ActiveTextureType
2478 std::vector<GLuint> mBoundTextures;
2481 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2483 TraceCallStack mBufferTrace;
2484 TraceCallStack mCullFaceTrace;
2485 TraceCallStack mEnableDisableTrace;
2486 TraceCallStack mShaderTrace;
2487 TraceCallStack mTextureTrace;
2488 TraceCallStack mTexParameterTrace;
2489 TraceCallStack mDrawTrace;
2490 TraceCallStack mDepthFunctionTrace;
2491 TraceCallStack mStencilFunctionTrace;
2492 TraceCallStack mScissorTrace;
2493 TraceCallStack mSetUniformTrace;
2494 TraceCallStack mViewportTrace;
2496 // Shaders & Uniforms
2497 GLuint mLastShaderIdUsed;
2498 GLuint mLastProgramIdUsed;
2499 GLuint mLastUniformIdUsed;
2500 typedef std::map<std::string, GLint> UniformIDMap;
2501 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2502 ProgramUniformMap mUniforms;
2504 template<typename T>
2505 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2508 typedef std::map<GLint, T> UniformValueMap;
2509 typedef std::map<GLuint, UniformValueMap> Map;
2511 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2518 typename Map::iterator it = Map::find(program);
2519 if(it == Map::end())
2521 // if its the first uniform for this program add it
2522 std::pair<typename Map::iterator, bool> result =
2523 Map::insert(typename Map::value_type(program, UniformValueMap()));
2527 UniformValueMap& uniforms = it->second;
2528 uniforms[uniform] = value;
2533 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2536 if(GetUniformValue(program, uniform, uniformValue))
2538 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2544 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2551 typename Map::const_iterator it = Map::find(program);
2552 if(it == Map::end())
2554 // Uniform values always initialised as 0
2559 const UniformValueMap& uniforms = it->second;
2560 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2561 if(it2 == uniforms.end())
2563 // Uniform values always initialised as 0
2567 value = it2->second;
2574 ProgramUniformValue<int> mProgramUniforms1i;
2575 ProgramUniformValue<float> mProgramUniforms1f;
2576 ProgramUniformValue<Vector2> mProgramUniforms2f;
2577 ProgramUniformValue<Vector3> mProgramUniforms3f;
2578 ProgramUniformValue<Vector4> mProgramUniforms4f;
2579 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2580 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2582 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2584 return mProgramUniforms1i;
2586 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2588 return mProgramUniforms1f;
2590 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2592 return mProgramUniforms2f;
2594 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2596 return mProgramUniforms3f;
2598 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2600 return mProgramUniforms4f;
2602 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2604 return mProgramUniformsMat4;
2606 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2608 return mProgramUniformsMat3;
2610 inline void SetVertexAttribArray(GLuint index, bool state)
2612 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2617 mVertexAttribArrayState[index] = state;
2618 mVertexAttribArrayChanged = true;
2621 ScissorParams mScissorParams;
2622 ColorMaskParams mColorMaskParams;
2626 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2632 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2638 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2640 return Vector2::ZERO;
2644 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2646 return Vector3::ZERO;
2650 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2652 return Vector4::ZERO;
2656 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2662 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2664 return Matrix3(Matrix());
2669 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2670 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2672 #endif // TEST_GL_ABSTRACTION_H