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
107 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
110 mFramebufferStatus |= 2;
113 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
118 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
119 * @return A vector containing the IDs that were bound.
121 inline const std::vector<GLuint>& GetBoundTextures() const
123 return mBoundTextures;
127 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
128 * @param[in] activeTextureUnit The specific active texture unit.
129 * @return A vector containing the IDs that were bound.
131 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
133 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
137 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
139 inline void ClearBoundTextures()
141 mBoundTextures.clear();
143 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
145 mActiveTextures[i].mBoundTextures.clear();
149 inline void BindTexture(GLenum target, GLuint texture) override
151 // Record the bound textures for future checks
154 mBoundTextures.push_back(texture);
156 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
158 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
162 std::stringstream out;
163 out << target << ", " << texture;
165 TraceCallStack::NamedParams namedParams;
166 namedParams["target"] = ToString(target);
167 namedParams["texture"] = ToString(texture);
169 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
172 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
174 mLastBlendColor.r = red;
175 mLastBlendColor.g = green;
176 mLastBlendColor.b = blue;
177 mLastBlendColor.a = alpha;
180 inline const Vector4& GetLastBlendColor() const
182 return mLastBlendColor;
185 inline void BlendEquation(GLenum mode) override
187 mLastBlendEquationRgb = mode;
188 mLastBlendEquationAlpha = mode;
191 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
193 mLastBlendEquationRgb = modeRgb;
194 mLastBlendEquationAlpha = modeAlpha;
197 inline GLenum GetLastBlendEquationRgb() const
199 return mLastBlendEquationRgb;
202 inline GLenum GetLastBlendEquationAlpha() const
204 return mLastBlendEquationAlpha;
207 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
209 mLastBlendFuncSrcRgb = sfactor;
210 mLastBlendFuncDstRgb = dfactor;
211 mLastBlendFuncSrcAlpha = sfactor;
212 mLastBlendFuncDstAlpha = dfactor;
215 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
217 mLastBlendFuncSrcRgb = srcRGB;
218 mLastBlendFuncDstRgb = dstRGB;
219 mLastBlendFuncSrcAlpha = srcAlpha;
220 mLastBlendFuncDstAlpha = dstAlpha;
223 inline GLenum GetLastBlendFuncSrcRgb() const
225 return mLastBlendFuncSrcRgb;
228 inline GLenum GetLastBlendFuncDstRgb() const
230 return mLastBlendFuncDstRgb;
233 inline GLenum GetLastBlendFuncSrcAlpha() const
235 return mLastBlendFuncSrcAlpha;
238 inline GLenum GetLastBlendFuncDstAlpha() const
240 return mLastBlendFuncDstAlpha;
243 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
245 mBufferDataCalls.push_back(size);
248 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
250 mBufferSubDataCalls.push_back(size);
253 inline GLenum CheckFramebufferStatus(GLenum target) override
255 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
256 //Framebuffer texture have been called
257 if(mFramebufferStatus == 7)
259 return GL_FRAMEBUFFER_COMPLETE;
262 return mCheckFramebufferStatusResult;
265 inline GLuint CheckFramebufferColorAttachmentCount()
267 return mFramebufferColorAttachmentCount;
270 inline GLenum CheckFramebufferDepthAttachment()
272 return mFramebufferDepthAttached;
275 inline GLenum CheckFramebufferStencilAttachment()
277 return mFramebufferStencilAttached;
280 inline void Clear(GLbitfield mask) override
283 mLastClearBitMask = mask;
286 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
288 mLastClearColor.r = red;
289 mLastClearColor.g = green;
290 mLastClearColor.b = blue;
291 mLastClearColor.a = alpha;
294 inline const Vector4& GetLastClearColor() const
296 return mLastClearColor;
299 inline void ClearDepthf(GLclampf depth) override
303 inline void ClearStencil(GLint s) override
305 std::stringstream out;
308 TraceCallStack::NamedParams namedParams;
309 namedParams["s"] = ToString(s);
311 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
314 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
316 mColorMaskParams.red = red;
317 mColorMaskParams.green = green;
318 mColorMaskParams.blue = blue;
319 mColorMaskParams.alpha = alpha;
322 inline void CompileShader(GLuint shader) override
324 std::stringstream out;
326 TraceCallStack::NamedParams namedParams;
327 namedParams["shader"] = ToString(shader);
329 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
332 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
334 std::stringstream out;
335 out << target << ", " << level << ", " << width << ", " << height;
337 TraceCallStack::NamedParams namedParams;
338 namedParams["target"] = ToString(target);
339 namedParams["level"] = ToString(level);
340 namedParams["internalformat"] = ToString(internalformat);
341 namedParams["width"] = ToString(width);
342 namedParams["height"] = ToString(height);
343 namedParams["border"] = ToString(border);
344 namedParams["size"] = ToString(imageSize);
346 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
349 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
351 std::stringstream out;
352 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
354 TraceCallStack::NamedParams namedParams;
355 namedParams["target"] = ToString(target);
356 namedParams["level"] = ToString(level);
357 namedParams["xoffset"] = ToString(xoffset);
358 namedParams["yoffset"] = ToString(yoffset);
359 namedParams["width"] = ToString(width);
360 namedParams["height"] = ToString(height);
361 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
364 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
368 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
372 inline GLuint CreateProgram(void) override
374 mShaderTrace.PushCall("CreateProgram", "");
376 ++mLastProgramIdUsed;
377 mUniforms[mLastProgramIdUsed] = UniformIDMap();
378 return mLastProgramIdUsed;
381 inline GLuint CreateShader(GLenum type) override
383 std::stringstream out;
386 TraceCallStack::NamedParams namedParams;
387 namedParams["type"] = ToString(type);
388 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
390 return ++mLastShaderIdUsed;
393 inline void CullFace(GLenum mode) override
395 std::stringstream out;
398 TraceCallStack::NamedParams namedParams;
399 namedParams["program"] = ToString(mode);
401 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
404 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
408 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
412 inline void DeleteProgram(GLuint program) override
414 std::stringstream out;
417 TraceCallStack::NamedParams namedParams;
418 namedParams["program"] = ToString(program);
420 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
423 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
427 inline void DeleteShader(GLuint shader) override
429 std::stringstream out;
432 TraceCallStack::NamedParams namedParams;
433 namedParams["shader"] = ToString(shader);
435 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
438 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
440 std::stringstream out;
441 out << "n:" << n << " textures[";
443 TraceCallStack::NamedParams namedParams;
445 for(GLsizei i = 0; i < n; i++)
447 out << (i > 0 ? ", " : "") << textures[i];
448 std::stringstream paramName;
449 paramName << "texture[" << i << "]";
450 namedParams[paramName.str()] = ToString(textures[i]);
451 mDeletedTextureIds.push_back(textures[i]);
452 mNumGeneratedTextures--;
456 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
459 inline bool CheckNoTexturesDeleted()
461 return mDeletedTextureIds.size() == 0;
464 inline bool CheckTextureDeleted(GLuint textureId)
468 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
470 if(*iter == textureId)
479 inline void ClearDeletedTextures()
481 mDeletedTextureIds.clear();
484 inline void DepthFunc(GLenum func) override
486 std::stringstream out;
489 TraceCallStack::NamedParams namedParams;
490 namedParams["func"] = ToString(func);
492 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
495 inline void DepthMask(GLboolean flag) override
497 mLastDepthMask = flag;
500 inline bool GetLastDepthMask() const
502 return mLastDepthMask;
505 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
509 inline void DetachShader(GLuint program, GLuint shader) override
511 std::stringstream out;
512 out << program << ", " << shader;
513 TraceCallStack::NamedParams namedParams;
514 namedParams["program"] = ToString(program);
515 namedParams["shader"] = ToString(shader);
516 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
519 inline void Disable(GLenum cap) override
521 std::stringstream out;
523 TraceCallStack::NamedParams namedParams;
524 namedParams["cap"] = ToString(cap);
525 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
528 inline void DisableVertexAttribArray(GLuint index) override
530 SetVertexAttribArray(index, false);
533 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
535 std::stringstream out;
536 out << mode << ", " << first << ", " << count;
537 TraceCallStack::NamedParams namedParams;
538 namedParams["mode"] = ToString(mode);
539 namedParams["first"] = ToString(first);
540 namedParams["count"] = ToString(count);
541 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
544 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
546 std::stringstream out;
547 out << mode << ", " << count << ", " << type << ", indices";
549 TraceCallStack::NamedParams namedParams;
550 namedParams["mode"] = ToString(mode);
551 namedParams["count"] = ToString(count);
552 namedParams["type"] = ToString(type);
553 // Skip void pointers - are they of any use?
554 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
557 inline void Enable(GLenum cap) override
559 std::stringstream out;
561 TraceCallStack::NamedParams namedParams;
562 namedParams["cap"] = ToString(cap);
563 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
566 inline void EnableVertexAttribArray(GLuint index) override
568 SetVertexAttribArray(index, true);
571 inline void Finish(void) override
575 inline void Flush(void) override
579 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
581 if(attachment == GL_DEPTH_ATTACHMENT)
583 mFramebufferDepthAttached = true;
585 else if(attachment == GL_STENCIL_ATTACHMENT)
587 mFramebufferStencilAttached = true;
591 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
594 mFramebufferStatus |= 4;
596 //We check 4 attachment colors
597 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
599 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
600 if((mFrameBufferColorStatus & mask) == 0)
602 mFrameBufferColorStatus |= mask;
603 ++mFramebufferColorAttachmentCount;
608 inline void FrontFace(GLenum mode) override
612 inline void GenBuffers(GLsizei n, GLuint* buffers) override
614 // avoids an assert in GpuBuffers
618 inline void GenerateMipmap(GLenum target) override
620 std::stringstream out;
622 TraceCallStack::NamedParams namedParams;
623 namedParams["target"] = ToString(target);
625 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
628 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
630 for(int i = 0; i < n; i++)
632 framebuffers[i] = i + 1;
635 //Add 001 bit, this function needs to be called the first one in the chain
636 mFramebufferStatus = 1;
639 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
641 for(int i = 0; i < n; i++)
643 renderbuffers[i] = i + 1;
648 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
649 * @param[in] ids A vector containing the next IDs to be generated
651 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
653 mNextTextureIds = ids;
656 inline const std::vector<GLuint>& GetNextTextureIds()
658 return mNextTextureIds;
661 inline void GenTextures(GLsizei count, GLuint* textures) override
663 for(int i = 0; i < count; ++i)
665 if(!mNextTextureIds.empty())
667 *(textures + i) = mNextTextureIds[0];
668 mNextTextureIds.erase(mNextTextureIds.begin());
672 *(textures + i) = ++mLastAutoTextureIdUsed;
674 mNumGeneratedTextures++;
677 TraceCallStack::NamedParams namedParams;
678 namedParams["count"] = ToString(count);
680 std::stringstream out;
681 for(int i = 0; i < count; i++)
688 std::ostringstream oss;
689 oss << "indices[" << i << "]";
690 namedParams[oss.str()] = ToString(textures[i]);
693 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
696 inline GLuint GetLastGenTextureId()
698 return mLastAutoTextureIdUsed;
701 inline GLuint GetNumGeneratedTextures()
703 return mNumGeneratedTextures;
706 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
710 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
715 *length = snprintf(name, bufsize, "sTexture");
716 *type = GL_SAMPLER_2D;
720 *length = snprintf(name, bufsize, "sEffect");
721 *type = GL_SAMPLER_2D;
725 *length = snprintf(name, bufsize, "sGloss");
726 *type = GL_SAMPLER_2D;
734 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
738 inline int GetAttribLocation(GLuint program, const char* name) override
740 std::string attribName(name);
742 for(unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i)
744 if(mStdAttribs[i] == attribName)
750 // 0 is a valid location
754 inline void GetBooleanv(GLenum pname, GLboolean* params) override
758 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
762 inline GLenum GetError(void) override
764 return mGetErrorResult;
767 inline void GetFloatv(GLenum pname, GLfloat* params) override
771 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
775 inline void GetIntegerv(GLenum pname, GLint* params) override
779 case GL_MAX_TEXTURE_SIZE:
782 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
785 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
786 *params = mNumBinaryFormats;
788 case GL_PROGRAM_BINARY_FORMATS_OES:
789 *params = mBinaryFormats;
794 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
799 *params = mLinkStatus;
801 case GL_PROGRAM_BINARY_LENGTH_OES:
802 *params = mProgramBinaryLength;
804 case GL_ACTIVE_UNIFORMS:
805 *params = mNumberOfActiveUniforms;
807 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
813 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
817 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
821 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
825 case GL_COMPILE_STATUS:
826 *params = mCompileStatus;
831 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
835 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
839 inline const GLubyte* GetString(GLenum name) override
841 return mGetStringResult;
844 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
848 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
852 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
856 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
860 inline GLint GetUniformLocation(GLuint program, const char* name) override
862 ProgramUniformMap::iterator it = mUniforms.find(program);
863 if(it == mUniforms.end())
865 // Not a valid program ID
866 mGetErrorResult = GL_INVALID_OPERATION;
870 UniformIDMap& uniformIDs = it->second;
871 UniformIDMap::iterator it2 = uniformIDs.find(name);
872 if(it2 == uniformIDs.end())
874 // Uniform not found, so add it...
875 uniformIDs[name] = ++mLastUniformIdUsed;
876 return mLastUniformIdUsed;
882 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
886 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
890 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
894 inline void Hint(GLenum target, GLenum mode) override
898 inline GLboolean IsBuffer(GLuint buffer) override
900 return mIsBufferResult;
903 inline GLboolean IsEnabled(GLenum cap) override
905 return mIsEnabledResult;
908 inline GLboolean IsFramebuffer(GLuint framebuffer) override
910 return mIsFramebufferResult;
913 inline GLboolean IsProgram(GLuint program) override
915 return mIsProgramResult;
918 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
920 return mIsRenderbufferResult;
923 inline GLboolean IsShader(GLuint shader) override
925 return mIsShaderResult;
928 inline GLboolean IsTexture(GLuint texture) override
930 return mIsTextureResult;
933 inline void LineWidth(GLfloat width) override
937 inline void LinkProgram(GLuint program) override
939 std::stringstream out;
942 TraceCallStack::NamedParams namedParams;
943 namedParams["program"] = ToString(program);
944 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
946 mNumberOfActiveUniforms = 3;
947 GetUniformLocation(program, "sTexture");
948 GetUniformLocation(program, "sEffect");
949 GetUniformLocation(program, "sGloss");
952 inline void PixelStorei(GLenum pname, GLint param) override
956 inline void PolygonOffset(GLfloat factor, GLfloat units) override
960 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
964 inline void ReleaseShaderCompiler(void) override
968 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
972 inline void SampleCoverage(GLclampf value, GLboolean invert) override
976 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
978 mScissorParams.x = x;
979 mScissorParams.y = y;
980 mScissorParams.width = width;
981 mScissorParams.height = height;
983 std::stringstream out;
984 out << x << ", " << y << ", " << width << ", " << height;
985 TraceCallStack::NamedParams namedParams;
986 namedParams["x"] = ToString(x);
987 namedParams["y"] = ToString(y);
988 namedParams["width"] = ToString(width);
989 namedParams["height"] = ToString(height);
990 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
993 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
997 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
999 std::string stringBuilder;
1000 for(int i = 0; i < count; ++i)
1002 stringBuilder += string[i];
1004 mShaderSources[shader] = stringBuilder;
1005 mLastShaderCompiled = shader;
1008 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1010 const std::string shaderSource = mShaderSources[shader];
1011 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1012 if(shaderSourceLength < bufsize)
1014 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1015 *length = shaderSourceLength;
1019 *length = bufsize - 1;
1020 strncpy(source, shaderSource.c_str(), *length);
1021 source[*length] = 0x0;
1025 inline std::string GetShaderSource(GLuint shader)
1027 return mShaderSources[shader];
1030 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1032 std::stringstream out;
1033 out << func << ", " << ref << ", " << mask;
1035 TraceCallStack::NamedParams namedParams;
1036 namedParams["func"] = ToString(func);
1037 namedParams["ref"] = ToString(ref);
1038 namedParams["mask"] = ToString(mask);
1040 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1043 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1045 std::stringstream out;
1046 out << face << ", " << func << ", " << ref << ", " << mask;
1048 TraceCallStack::NamedParams namedParams;
1049 namedParams["face"] = ToString(face);
1050 namedParams["func"] = ToString(func);
1051 namedParams["ref"] = ToString(ref);
1052 namedParams["mask"] = ToString(mask);
1054 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1057 inline void StencilMask(GLuint mask) override
1059 std::stringstream out;
1062 TraceCallStack::NamedParams namedParams;
1063 namedParams["mask"] = ToString(mask);
1065 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1068 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1070 std::stringstream out;
1071 out << face << ", " << mask;
1073 TraceCallStack::NamedParams namedParams;
1074 namedParams["face"] = ToString(face);
1075 namedParams["mask"] = ToString(mask);
1077 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1080 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1082 std::stringstream out;
1083 out << fail << ", " << zfail << ", " << zpass;
1085 TraceCallStack::NamedParams namedParams;
1086 namedParams["fail"] = ToString(fail);
1087 namedParams["zfail"] = ToString(zfail);
1088 namedParams["zpass"] = ToString(zpass);
1090 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1093 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1095 std::stringstream out;
1096 out << face << ", " << fail << ", " << zfail << "," << zpass;
1098 TraceCallStack::NamedParams namedParams;
1099 namedParams["face"] = ToString(face);
1100 namedParams["fail"] = ToString(fail);
1101 namedParams["zfail"] = ToString(zfail);
1102 namedParams["zpass"] = ToString(zpass);
1104 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1107 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1109 std::stringstream out;
1110 out << target << ", " << level << ", " << width << ", " << height;
1112 TraceCallStack::NamedParams namedParams;
1113 namedParams["target"] = ToString(target);
1114 namedParams["level"] = ToString(level);
1115 namedParams["internalformat"] = ToString(internalformat);
1116 namedParams["width"] = ToString(width);
1117 namedParams["height"] = ToString(height);
1118 namedParams["border"] = ToString(border);
1119 namedParams["format"] = ToString(format);
1120 namedParams["type"] = ToString(type);
1122 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1125 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1127 std::stringstream out;
1128 out << target << ", " << pname << ", " << param;
1130 TraceCallStack::NamedParams namedParams;
1131 namedParams["target"] = ToString(target);
1132 namedParams["pname"] = ToString(pname);
1133 namedParams["param"] = ToString(param);
1135 mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
1138 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1140 std::stringstream out;
1141 out << target << ", " << pname << ", " << params[0];
1143 TraceCallStack::NamedParams namedParams;
1144 namedParams["target"] = ToString(target);
1145 namedParams["pname"] = ToString(pname);
1146 namedParams["params[0]"] = ToString(params[0]);
1148 mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1151 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1153 std::stringstream out;
1154 out << std::hex << target << ", " << pname << ", " << param;
1155 std::string params = out.str();
1158 out << std::hex << target;
1159 TraceCallStack::NamedParams namedParams;
1160 namedParams["target"] = out.str();
1162 out << std::hex << pname;
1163 namedParams["pname"] = out.str();
1165 out << std::hex << param;
1166 namedParams["param"] = out.str();
1167 mTexParamaterTrace.PushCall("TexParameteri", params, namedParams);
1170 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1172 std::stringstream out;
1173 out << target << ", " << pname << ", " << params[0];
1174 TraceCallStack::NamedParams namedParams;
1175 namedParams["target"] = ToString(target);
1176 namedParams["pname"] = ToString(pname);
1177 namedParams["params[0]"] = ToString(params[0]);
1178 mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1181 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1183 std::stringstream out;
1184 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1186 TraceCallStack::NamedParams namedParams;
1187 namedParams["target"] = ToString(target);
1188 namedParams["level"] = ToString(level);
1189 namedParams["xoffset"] = ToString(xoffset);
1190 namedParams["yoffset"] = ToString(yoffset);
1191 namedParams["width"] = ToString(width);
1192 namedParams["height"] = ToString(height);
1193 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1196 inline void Uniform1f(GLint location, GLfloat value) override
1198 std::string params = ToString(value);
1199 AddUniformCallToTraceStack(location, params);
1201 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1203 mGetErrorResult = GL_INVALID_OPERATION;
1207 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1210 for(int i = 0; i < count; ++i)
1212 params = params + ToString(v[i]) + ",";
1215 AddUniformCallToTraceStack(location, params);
1217 for(int i = 0; i < count; ++i)
1219 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1221 mGetErrorResult = GL_INVALID_OPERATION;
1227 inline void Uniform1i(GLint location, GLint x) override
1229 std::string params = ToString(x);
1231 AddUniformCallToTraceStack(location, params);
1233 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1235 mGetErrorResult = GL_INVALID_OPERATION;
1239 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1241 std::string params = ToString(v);
1242 AddUniformCallToTraceStack(location, params);
1244 for(int i = 0; i < count; ++i)
1246 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1250 mGetErrorResult = GL_INVALID_OPERATION;
1256 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1258 std::string params = ToString(x) + "," + ToString(y);
1259 AddUniformCallToTraceStack(location, params);
1261 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1265 mGetErrorResult = GL_INVALID_OPERATION;
1269 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1271 std::string params = ToString(v);
1272 AddUniformCallToTraceStack(location, params);
1274 for(int i = 0; i < count; ++i)
1276 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1278 Vector2(v[2 * i], v[2 * i + 1])))
1280 mGetErrorResult = GL_INVALID_OPERATION;
1286 inline void Uniform2i(GLint location, GLint x, GLint y) override
1288 std::string params = ToString(x) + "," + ToString(y);
1289 AddUniformCallToTraceStack(location, params);
1292 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1294 std::string params = ToString(v);
1295 AddUniformCallToTraceStack(location, params);
1298 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1300 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1301 AddUniformCallToTraceStack(location, params);
1303 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1307 mGetErrorResult = GL_INVALID_OPERATION;
1311 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1313 std::string params = ToString(v);
1314 AddUniformCallToTraceStack(location, params);
1316 for(int i = 0; i < count; ++i)
1318 if(!mProgramUniforms3f.SetUniformValue(
1321 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1323 mGetErrorResult = GL_INVALID_OPERATION;
1329 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1331 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1332 AddUniformCallToTraceStack(location, params);
1335 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1337 std::string params = ToString(v);
1338 AddUniformCallToTraceStack(location, params);
1341 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1343 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1344 AddUniformCallToTraceStack(location, params);
1346 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1348 Vector4(x, y, z, w)))
1350 mGetErrorResult = GL_INVALID_OPERATION;
1354 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1356 std::string params = ToString(v);
1357 AddUniformCallToTraceStack(location, params);
1359 for(int i = 0; i < count; ++i)
1361 if(!mProgramUniforms4f.SetUniformValue(
1364 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1366 mGetErrorResult = GL_INVALID_OPERATION;
1372 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1374 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1375 AddUniformCallToTraceStack(location, params);
1378 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1380 std::string params = ToString(v);
1381 AddUniformCallToTraceStack(location, params);
1384 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1386 std::string params = ToString(value);
1387 AddUniformCallToTraceStack(location, params);
1390 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1392 std::string params = ToString(value);
1393 AddUniformCallToTraceStack(location, params);
1395 for(int i = 0; i < count; ++i)
1397 if(!mProgramUniformsMat3.SetUniformValue(
1400 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1402 mGetErrorResult = GL_INVALID_OPERATION;
1408 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1410 std::string params = ToString(value);
1411 AddUniformCallToTraceStack(location, params);
1413 for(int i = 0; i < count; ++i)
1415 if(!mProgramUniformsMat4.SetUniformValue(
1420 mGetErrorResult = GL_INVALID_OPERATION;
1426 inline void UseProgram(GLuint program) override
1428 mCurrentProgram = program;
1431 inline void ValidateProgram(GLuint program) override
1435 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1439 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1443 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1447 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1451 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1455 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1459 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1463 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1467 inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1471 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1473 std::string commaString(", ");
1474 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1476 mViewportTrace.PushCall("Viewport", params);
1481 inline void ReadBuffer(GLenum mode) override
1485 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1489 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
1493 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
1497 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1501 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1505 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
1509 inline void GenQueries(GLsizei n, GLuint* ids) override
1513 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1517 inline GLboolean IsQuery(GLuint id) override
1522 inline void BeginQuery(GLenum target, GLuint id) override
1526 inline void EndQuery(GLenum target) override
1530 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1534 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1538 inline GLboolean UnmapBuffer(GLenum target) override
1543 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1547 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1551 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1555 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1559 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1563 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1567 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1571 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1575 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1579 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1583 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1587 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1592 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1596 inline void BindVertexArray(GLuint array) override
1600 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1604 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1608 inline GLboolean IsVertexArray(GLuint array) override
1613 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1617 inline void BeginTransformFeedback(GLenum primitiveMode) override
1621 inline void EndTransformFeedback(void) override
1625 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1629 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1633 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1637 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1641 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1645 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1649 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1653 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1657 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1661 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1665 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1669 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1673 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1678 inline void Uniform1ui(GLint location, GLuint v0) override
1682 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1686 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1690 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1694 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1698 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1702 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1706 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1710 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1714 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1718 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1722 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1726 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1731 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1735 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1739 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1743 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1745 return GL_INVALID_INDEX;
1748 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1752 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1756 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1760 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1764 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1768 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1773 inline GLboolean IsSync(GLsync sync) override
1778 inline void DeleteSync(GLsync sync) override
1782 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1787 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1791 inline void GetInteger64v(GLenum pname, GLint64* params) override
1795 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1799 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1803 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1807 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1811 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1815 inline GLboolean IsSampler(GLuint sampler) override
1820 inline void BindSampler(GLuint unit, GLuint sampler) override
1824 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1828 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1832 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1836 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1840 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1844 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1848 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1852 inline void BindTransformFeedback(GLenum target, GLuint id) override
1856 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1860 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1864 inline GLboolean IsTransformFeedback(GLuint id) override
1869 inline void PauseTransformFeedback(void) override
1873 inline void ResumeTransformFeedback(void) override
1877 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1879 mGetProgramBinaryCalled = true;
1882 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1886 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1890 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1894 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1898 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1902 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1906 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1910 inline void BlendBarrier(void)
1915 inline void AddUniformCallToTraceStack(GLint location, std::string& value)
1917 std::string name = "<not found>";
1918 bool matched = false;
1920 UniformIDMap& map = mUniforms[mCurrentProgram];
1921 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1923 if(it->second == location)
1933 mSetUniformTrace.PushCall(name, value);
1937 public: // TEST FUNCTIONS
1938 inline void SetCompileStatus(GLuint value)
1940 mCompileStatus = value;
1942 inline void SetLinkStatus(GLuint value)
1944 mLinkStatus = value;
1946 inline void SetGetAttribLocationResult(int result)
1948 mGetAttribLocationResult = result;
1950 inline void SetGetErrorResult(GLenum result)
1952 mGetErrorResult = result;
1954 inline void SetGetStringResult(GLubyte* result)
1956 mGetStringResult = result;
1958 inline void SetIsBufferResult(GLboolean result)
1960 mIsBufferResult = result;
1962 inline void SetIsEnabledResult(GLboolean result)
1964 mIsEnabledResult = result;
1966 inline void SetIsFramebufferResult(GLboolean result)
1968 mIsFramebufferResult = result;
1970 inline void SetIsProgramResult(GLboolean result)
1972 mIsProgramResult = result;
1974 inline void SetIsRenderbufferResult(GLboolean result)
1976 mIsRenderbufferResult = result;
1978 inline void SetIsShaderResult(GLboolean result)
1980 mIsShaderResult = result;
1982 inline void SetIsTextureResult(GLboolean result)
1984 mIsTextureResult = result;
1986 inline void SetCheckFramebufferStatusResult(GLenum result)
1988 mCheckFramebufferStatusResult = result;
1990 inline void SetNumBinaryFormats(GLint numFormats)
1992 mNumBinaryFormats = numFormats;
1994 inline void SetBinaryFormats(GLint binaryFormats)
1996 mBinaryFormats = binaryFormats;
1998 inline void SetProgramBinaryLength(GLint length)
2000 mProgramBinaryLength = length;
2003 inline bool GetVertexAttribArrayState(GLuint index)
2005 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2010 return mVertexAttribArrayState[index];
2012 inline void ClearVertexAttribArrayChanged()
2014 mVertexAttribArrayChanged = false;
2016 inline bool GetVertexAttribArrayChanged()
2018 return mVertexAttribArrayChanged;
2021 //Methods for CullFace verification
2022 inline void EnableCullFaceCallTrace(bool enable)
2024 mCullFaceTrace.Enable(enable);
2026 inline void ResetCullFaceCallStack()
2028 mCullFaceTrace.Reset();
2030 inline TraceCallStack& GetCullFaceTrace()
2032 return mCullFaceTrace;
2035 //Methods for Enable/Disable call verification
2036 inline void EnableEnableDisableCallTrace(bool enable)
2038 mEnableDisableTrace.Enable(enable);
2040 inline void ResetEnableDisableCallStack()
2042 mEnableDisableTrace.Reset();
2044 inline TraceCallStack& GetEnableDisableTrace()
2046 return mEnableDisableTrace;
2049 //Methods for Shader verification
2050 inline void EnableShaderCallTrace(bool enable)
2052 mShaderTrace.Enable(enable);
2054 inline void ResetShaderCallStack()
2056 mShaderTrace.Reset();
2058 inline TraceCallStack& GetShaderTrace()
2060 return mShaderTrace;
2063 //Methods for Texture verification
2064 inline void EnableTextureCallTrace(bool enable)
2066 mTextureTrace.Enable(enable);
2068 inline void ResetTextureCallStack()
2070 mTextureTrace.Reset();
2072 inline TraceCallStack& GetTextureTrace()
2074 return mTextureTrace;
2077 //Methods for Texture verification
2078 inline void EnableTexParameterCallTrace(bool enable)
2080 mTexParamaterTrace.Enable(enable);
2082 inline void ResetTexParameterCallStack()
2084 mTexParamaterTrace.Reset();
2086 inline TraceCallStack& GetTexParameterTrace()
2088 return mTexParamaterTrace;
2091 //Methods for Draw verification
2092 inline void EnableDrawCallTrace(bool enable)
2094 mDrawTrace.Enable(enable);
2096 inline void ResetDrawCallStack()
2100 inline TraceCallStack& GetDrawTrace()
2105 //Methods for Depth function verification
2106 inline void EnableDepthFunctionCallTrace(bool enable)
2108 mDepthFunctionTrace.Enable(enable);
2110 inline void ResetDepthFunctionCallStack()
2112 mDepthFunctionTrace.Reset();
2114 inline TraceCallStack& GetDepthFunctionTrace()
2116 return mDepthFunctionTrace;
2119 //Methods for Stencil function verification
2120 inline void EnableStencilFunctionCallTrace(bool enable)
2122 mStencilFunctionTrace.Enable(enable);
2124 inline void ResetStencilFunctionCallStack()
2126 mStencilFunctionTrace.Reset();
2128 inline TraceCallStack& GetStencilFunctionTrace()
2130 return mStencilFunctionTrace;
2133 //Methods for Scissor verification
2134 inline void EnableScissorCallTrace(bool enable)
2136 mScissorTrace.Enable(enable);
2138 inline void ResetScissorCallStack()
2140 mScissorTrace.Reset();
2142 inline TraceCallStack& GetScissorTrace()
2144 return mScissorTrace;
2147 //Methods for Uniform function verification
2148 inline void EnableSetUniformCallTrace(bool enable)
2150 mSetUniformTrace.Enable(enable);
2152 inline void ResetSetUniformCallStack()
2154 mSetUniformTrace.Reset();
2156 inline TraceCallStack& GetSetUniformTrace()
2158 return mSetUniformTrace;
2161 //Methods for Viewport verification
2162 inline void EnableViewportCallTrace(bool enable)
2164 mViewportTrace.Enable(enable);
2166 inline void ResetViewportCallStack()
2168 mViewportTrace.Reset();
2170 inline TraceCallStack& GetViewportTrace()
2172 return mViewportTrace;
2175 template<typename T>
2176 inline bool GetUniformValue(const char* name, T& value) const
2178 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2179 program_it != mUniforms.end();
2182 const UniformIDMap& uniformIDs = program_it->second;
2184 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2185 if(uniform_it != uniformIDs.end())
2187 // found one matching uniform name, lets check the value...
2188 GLuint programId = program_it->first;
2189 GLint uniformId = uniform_it->second;
2191 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2192 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2198 template<typename T>
2199 inline bool CheckUniformValue(const char* name, const T& value) const
2201 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2202 program_it != mUniforms.end();
2205 const UniformIDMap& uniformIDs = program_it->second;
2207 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2208 if(uniform_it != uniformIDs.end())
2210 // found one matching uniform name, lets check the value...
2211 GLuint programId = program_it->first;
2212 GLint uniformId = uniform_it->second;
2214 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2215 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2217 // the value matches
2223 fprintf(stderr, "Not found, printing possible values:\n");
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);
2239 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2241 std::stringstream out;
2242 out << uniform_it->first << ": " << origValue;
2243 fprintf(stderr, "%s\n", out.str().c_str());
2250 template<typename T>
2251 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2253 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2254 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2257 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2259 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2260 program_it != mUniforms.end();
2263 const UniformIDMap& uniformIDs = program_it->second;
2265 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2266 if(uniform_it != uniformIDs.end())
2268 programId = program_it->first;
2269 uniformId = uniform_it->second;
2276 inline GLuint GetLastShaderCompiled() const
2278 return mLastShaderCompiled;
2281 inline GLuint GetLastProgramCreated() const
2283 return mLastProgramIdUsed;
2286 inline GLbitfield GetLastClearMask() const
2288 return mLastClearBitMask;
2293 ATTRIB_UNKNOWN = -1,
2298 ATTRIB_BONE_WEIGHTS,
2299 ATTRIB_BONE_INDICES,
2303 struct ScissorParams
2319 // Methods to check scissor tests
2320 inline const ScissorParams& GetScissorParams() const
2322 return mScissorParams;
2325 struct ColorMaskParams
2341 inline bool GetProgramBinaryCalled() const
2343 return mGetProgramBinaryCalled;
2346 inline unsigned int GetClearCountCalled() const
2351 inline const ColorMaskParams& GetColorMaskParams() const
2353 return mColorMaskParams;
2356 typedef std::vector<size_t> BufferDataCalls;
2357 inline const BufferDataCalls& GetBufferDataCalls() const
2359 return mBufferDataCalls;
2361 inline void ResetBufferDataCalls()
2363 mBufferDataCalls.clear();
2366 typedef std::vector<size_t> BufferSubDataCalls;
2367 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2369 return mBufferSubDataCalls;
2371 inline void ResetBufferSubDataCalls()
2373 mBufferSubDataCalls.clear();
2377 GLuint mCurrentProgram;
2378 GLuint mCompileStatus;
2379 BufferDataCalls mBufferDataCalls;
2380 BufferSubDataCalls mBufferSubDataCalls;
2382 GLint mNumberOfActiveUniforms;
2383 GLint mGetAttribLocationResult;
2384 GLenum mGetErrorResult;
2385 GLubyte* mGetStringResult;
2386 GLboolean mIsBufferResult;
2387 GLboolean mIsEnabledResult;
2388 GLboolean mIsFramebufferResult;
2389 GLboolean mIsProgramResult;
2390 GLboolean mIsRenderbufferResult;
2391 GLboolean mIsShaderResult;
2392 GLboolean mIsTextureResult;
2393 GLenum mActiveTextureUnit;
2394 GLenum mCheckFramebufferStatusResult;
2395 GLint mFramebufferStatus;
2396 GLenum mFramebufferDepthAttached;
2397 GLenum mFramebufferStencilAttached;
2398 GLuint mFramebufferColorAttachmentCount;
2399 GLuint mFrameBufferColorStatus;
2400 GLint mNumBinaryFormats;
2401 GLint mBinaryFormats;
2402 GLint mProgramBinaryLength;
2403 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2404 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2405 bool mGetProgramBinaryCalled;
2406 typedef std::map<GLuint, std::string> ShaderSourceMap;
2407 ShaderSourceMap mShaderSources;
2408 GLuint mLastShaderCompiled;
2409 GLbitfield mLastClearBitMask;
2410 Vector4 mLastClearColor;
2411 unsigned int mClearCount;
2413 Vector4 mLastBlendColor;
2414 GLenum mLastBlendEquationRgb;
2415 GLenum mLastBlendEquationAlpha;
2416 GLenum mLastBlendFuncSrcRgb;
2417 GLenum mLastBlendFuncDstRgb;
2418 GLenum mLastBlendFuncSrcAlpha;
2419 GLenum mLastBlendFuncDstAlpha;
2421 GLboolean mLastDepthMask;
2423 // Data for manipulating the IDs returned by GenTextures
2424 GLuint mLastAutoTextureIdUsed;
2425 GLuint mNumGeneratedTextures;
2426 std::vector<GLuint> mNextTextureIds;
2427 std::vector<GLuint> mDeletedTextureIds;
2428 std::vector<GLuint> mBoundTextures;
2430 struct ActiveTextureType
2432 std::vector<GLuint> mBoundTextures;
2435 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2437 TraceCallStack mCullFaceTrace;
2438 TraceCallStack mEnableDisableTrace;
2439 TraceCallStack mShaderTrace;
2440 TraceCallStack mTextureTrace{"GlA Texture:"};
2441 TraceCallStack mTexParamaterTrace;
2442 TraceCallStack mDrawTrace;
2443 TraceCallStack mDepthFunctionTrace;
2444 TraceCallStack mStencilFunctionTrace;
2445 TraceCallStack mScissorTrace;
2446 TraceCallStack mSetUniformTrace;
2447 TraceCallStack mViewportTrace;
2449 // Shaders & Uniforms
2450 GLuint mLastShaderIdUsed;
2451 GLuint mLastProgramIdUsed;
2452 GLuint mLastUniformIdUsed;
2453 typedef std::map<std::string, GLint> UniformIDMap;
2454 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2455 ProgramUniformMap mUniforms;
2457 template<typename T>
2458 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2461 typedef std::map<GLint, T> UniformValueMap;
2462 typedef std::map<GLuint, UniformValueMap> Map;
2464 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2471 typename Map::iterator it = Map::find(program);
2472 if(it == Map::end())
2474 // if its the first uniform for this program add it
2475 std::pair<typename Map::iterator, bool> result =
2476 Map::insert(typename Map::value_type(program, UniformValueMap()));
2480 UniformValueMap& uniforms = it->second;
2481 uniforms[uniform] = value;
2486 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2489 if(GetUniformValue(program, uniform, uniformValue))
2491 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2497 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2504 typename Map::const_iterator it = Map::find(program);
2505 if(it == Map::end())
2507 // Uniform values always initialised as 0
2512 const UniformValueMap& uniforms = it->second;
2513 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2514 if(it2 == uniforms.end())
2516 // Uniform values always initialised as 0
2520 value = it2->second;
2527 ProgramUniformValue<int> mProgramUniforms1i;
2528 ProgramUniformValue<float> mProgramUniforms1f;
2529 ProgramUniformValue<Vector2> mProgramUniforms2f;
2530 ProgramUniformValue<Vector3> mProgramUniforms3f;
2531 ProgramUniformValue<Vector4> mProgramUniforms4f;
2532 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2533 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2535 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2537 return mProgramUniforms1i;
2539 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2541 return mProgramUniforms1f;
2543 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2545 return mProgramUniforms2f;
2547 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2549 return mProgramUniforms3f;
2551 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2553 return mProgramUniforms4f;
2555 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2557 return mProgramUniformsMat4;
2559 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2561 return mProgramUniformsMat3;
2563 inline void SetVertexAttribArray(GLuint index, bool state)
2565 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2570 mVertexAttribArrayState[index] = state;
2571 mVertexAttribArrayChanged = true;
2574 ScissorParams mScissorParams;
2575 ColorMaskParams mColorMaskParams;
2579 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2585 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2591 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2593 return Vector2::ZERO;
2597 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2599 return Vector3::ZERO;
2603 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2605 return Vector4::ZERO;
2609 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2615 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2617 return Matrix3(Matrix());
2622 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2623 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2625 #endif // TEST_GL_ABSTRACTION_H