1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2020 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 << ", " << textures << " = [";
443 TraceCallStack::NamedParams namedParams;
445 for(GLsizei i = 0; i < n; i++)
447 out << 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 << target << ", " << pname << ", " << param;
1155 TraceCallStack::NamedParams namedParams;
1156 namedParams["target"] = ToString(target);
1157 namedParams["pname"] = ToString(pname);
1158 namedParams["param"] = ToString(param);
1159 mTexParamaterTrace.PushCall("TexParameteri", out.str(), namedParams);
1162 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1164 std::stringstream out;
1165 out << target << ", " << pname << ", " << params[0];
1166 TraceCallStack::NamedParams namedParams;
1167 namedParams["target"] = ToString(target);
1168 namedParams["pname"] = ToString(pname);
1169 namedParams["params[0]"] = ToString(params[0]);
1170 mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1173 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1175 std::stringstream out;
1176 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1178 TraceCallStack::NamedParams namedParams;
1179 namedParams["target"] = ToString(target);
1180 namedParams["level"] = ToString(level);
1181 namedParams["xoffset"] = ToString(xoffset);
1182 namedParams["yoffset"] = ToString(yoffset);
1183 namedParams["width"] = ToString(width);
1184 namedParams["height"] = ToString(height);
1185 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1188 inline void Uniform1f(GLint location, GLfloat value) override
1190 std::string params = ToString(value);
1191 AddUniformCallToTraceStack(location, params);
1193 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1195 mGetErrorResult = GL_INVALID_OPERATION;
1199 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1202 for(int i = 0; i < count; ++i)
1204 params = params + ToString(v[i]) + ",";
1207 AddUniformCallToTraceStack(location, params);
1209 for(int i = 0; i < count; ++i)
1211 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1213 mGetErrorResult = GL_INVALID_OPERATION;
1219 inline void Uniform1i(GLint location, GLint x) override
1221 std::string params = ToString(x);
1223 AddUniformCallToTraceStack(location, params);
1225 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1227 mGetErrorResult = GL_INVALID_OPERATION;
1231 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1233 std::string params = ToString(v);
1234 AddUniformCallToTraceStack(location, params);
1236 for(int i = 0; i < count; ++i)
1238 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1242 mGetErrorResult = GL_INVALID_OPERATION;
1248 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1250 std::string params = ToString(x) + "," + ToString(y);
1251 AddUniformCallToTraceStack(location, params);
1253 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1257 mGetErrorResult = GL_INVALID_OPERATION;
1261 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1263 std::string params = ToString(v);
1264 AddUniformCallToTraceStack(location, params);
1266 for(int i = 0; i < count; ++i)
1268 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1270 Vector2(v[2 * i], v[2 * i + 1])))
1272 mGetErrorResult = GL_INVALID_OPERATION;
1278 inline void Uniform2i(GLint location, GLint x, GLint y) override
1280 std::string params = ToString(x) + "," + ToString(y);
1281 AddUniformCallToTraceStack(location, params);
1284 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1286 std::string params = ToString(v);
1287 AddUniformCallToTraceStack(location, params);
1290 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1292 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1293 AddUniformCallToTraceStack(location, params);
1295 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1299 mGetErrorResult = GL_INVALID_OPERATION;
1303 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1305 std::string params = ToString(v);
1306 AddUniformCallToTraceStack(location, params);
1308 for(int i = 0; i < count; ++i)
1310 if(!mProgramUniforms3f.SetUniformValue(
1313 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1315 mGetErrorResult = GL_INVALID_OPERATION;
1321 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1323 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1324 AddUniformCallToTraceStack(location, params);
1327 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1329 std::string params = ToString(v);
1330 AddUniformCallToTraceStack(location, params);
1333 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1335 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1336 AddUniformCallToTraceStack(location, params);
1338 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1340 Vector4(x, y, z, w)))
1342 mGetErrorResult = GL_INVALID_OPERATION;
1346 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1348 std::string params = ToString(v);
1349 AddUniformCallToTraceStack(location, params);
1351 for(int i = 0; i < count; ++i)
1353 if(!mProgramUniforms4f.SetUniformValue(
1356 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1358 mGetErrorResult = GL_INVALID_OPERATION;
1364 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1366 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1367 AddUniformCallToTraceStack(location, params);
1370 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1372 std::string params = ToString(v);
1373 AddUniformCallToTraceStack(location, params);
1376 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1378 std::string params = ToString(value);
1379 AddUniformCallToTraceStack(location, params);
1382 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1384 std::string params = ToString(value);
1385 AddUniformCallToTraceStack(location, params);
1387 for(int i = 0; i < count; ++i)
1389 if(!mProgramUniformsMat3.SetUniformValue(
1392 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1394 mGetErrorResult = GL_INVALID_OPERATION;
1400 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1402 std::string params = ToString(value);
1403 AddUniformCallToTraceStack(location, params);
1405 for(int i = 0; i < count; ++i)
1407 if(!mProgramUniformsMat4.SetUniformValue(
1412 mGetErrorResult = GL_INVALID_OPERATION;
1418 inline void UseProgram(GLuint program) override
1420 mCurrentProgram = program;
1423 inline void ValidateProgram(GLuint program) override
1427 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1431 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1435 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1439 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1443 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1447 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1451 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1455 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1459 inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1463 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1465 std::string commaString(", ");
1466 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1468 mViewportTrace.PushCall("Viewport", params);
1473 inline void ReadBuffer(GLenum mode) override
1477 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1481 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
1485 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
1489 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1493 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1497 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
1501 inline void GenQueries(GLsizei n, GLuint* ids) override
1505 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1509 inline GLboolean IsQuery(GLuint id) override
1514 inline void BeginQuery(GLenum target, GLuint id) override
1518 inline void EndQuery(GLenum target) override
1522 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1526 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1530 inline GLboolean UnmapBuffer(GLenum target) override
1535 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1539 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1543 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1547 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1551 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1555 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1559 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1563 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1567 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1571 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1575 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1579 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1584 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1588 inline void BindVertexArray(GLuint array) override
1592 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1596 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1600 inline GLboolean IsVertexArray(GLuint array) override
1605 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1609 inline void BeginTransformFeedback(GLenum primitiveMode) override
1613 inline void EndTransformFeedback(void) override
1617 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1621 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1625 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1629 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1633 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1637 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1641 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1645 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1649 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1653 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1657 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1661 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1665 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1670 inline void Uniform1ui(GLint location, GLuint v0) override
1674 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1678 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1682 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1686 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1690 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1694 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1698 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1702 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1706 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1710 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1714 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1718 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1723 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1727 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1731 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1735 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1737 return GL_INVALID_INDEX;
1740 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1744 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1748 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1752 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1756 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1760 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1765 inline GLboolean IsSync(GLsync sync) override
1770 inline void DeleteSync(GLsync sync) override
1774 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1779 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1783 inline void GetInteger64v(GLenum pname, GLint64* params) override
1787 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1791 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1795 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1799 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1803 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1807 inline GLboolean IsSampler(GLuint sampler) override
1812 inline void BindSampler(GLuint unit, GLuint sampler) override
1816 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1820 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1824 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1828 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1832 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1836 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1840 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1844 inline void BindTransformFeedback(GLenum target, GLuint id) override
1848 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1852 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1856 inline GLboolean IsTransformFeedback(GLuint id) override
1861 inline void PauseTransformFeedback(void) override
1865 inline void ResumeTransformFeedback(void) override
1869 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1871 mGetProgramBinaryCalled = true;
1874 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1878 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1882 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1886 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1890 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1894 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1898 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1902 inline void BlendBarrier(void)
1907 inline void AddUniformCallToTraceStack(GLint location, std::string& value)
1909 std::string name = "<not found>";
1910 bool matched = false;
1912 UniformIDMap& map = mUniforms[mCurrentProgram];
1913 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1915 if(it->second == location)
1925 mSetUniformTrace.PushCall(name, value);
1929 public: // TEST FUNCTIONS
1930 inline void SetCompileStatus(GLuint value)
1932 mCompileStatus = value;
1934 inline void SetLinkStatus(GLuint value)
1936 mLinkStatus = value;
1938 inline void SetGetAttribLocationResult(int result)
1940 mGetAttribLocationResult = result;
1942 inline void SetGetErrorResult(GLenum result)
1944 mGetErrorResult = result;
1946 inline void SetGetStringResult(GLubyte* result)
1948 mGetStringResult = result;
1950 inline void SetIsBufferResult(GLboolean result)
1952 mIsBufferResult = result;
1954 inline void SetIsEnabledResult(GLboolean result)
1956 mIsEnabledResult = result;
1958 inline void SetIsFramebufferResult(GLboolean result)
1960 mIsFramebufferResult = result;
1962 inline void SetIsProgramResult(GLboolean result)
1964 mIsProgramResult = result;
1966 inline void SetIsRenderbufferResult(GLboolean result)
1968 mIsRenderbufferResult = result;
1970 inline void SetIsShaderResult(GLboolean result)
1972 mIsShaderResult = result;
1974 inline void SetIsTextureResult(GLboolean result)
1976 mIsTextureResult = result;
1978 inline void SetCheckFramebufferStatusResult(GLenum result)
1980 mCheckFramebufferStatusResult = result;
1982 inline void SetNumBinaryFormats(GLint numFormats)
1984 mNumBinaryFormats = numFormats;
1986 inline void SetBinaryFormats(GLint binaryFormats)
1988 mBinaryFormats = binaryFormats;
1990 inline void SetProgramBinaryLength(GLint length)
1992 mProgramBinaryLength = length;
1995 inline bool GetVertexAttribArrayState(GLuint index)
1997 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2002 return mVertexAttribArrayState[index];
2004 inline void ClearVertexAttribArrayChanged()
2006 mVertexAttribArrayChanged = false;
2008 inline bool GetVertexAttribArrayChanged()
2010 return mVertexAttribArrayChanged;
2013 //Methods for CullFace verification
2014 inline void EnableCullFaceCallTrace(bool enable)
2016 mCullFaceTrace.Enable(enable);
2018 inline void ResetCullFaceCallStack()
2020 mCullFaceTrace.Reset();
2022 inline TraceCallStack& GetCullFaceTrace()
2024 return mCullFaceTrace;
2027 //Methods for Enable/Disable call verification
2028 inline void EnableEnableDisableCallTrace(bool enable)
2030 mEnableDisableTrace.Enable(enable);
2032 inline void ResetEnableDisableCallStack()
2034 mEnableDisableTrace.Reset();
2036 inline TraceCallStack& GetEnableDisableTrace()
2038 return mEnableDisableTrace;
2041 //Methods for Shader verification
2042 inline void EnableShaderCallTrace(bool enable)
2044 mShaderTrace.Enable(enable);
2046 inline void ResetShaderCallStack()
2048 mShaderTrace.Reset();
2050 inline TraceCallStack& GetShaderTrace()
2052 return mShaderTrace;
2055 //Methods for Texture verification
2056 inline void EnableTextureCallTrace(bool enable)
2058 mTextureTrace.Enable(enable);
2060 inline void ResetTextureCallStack()
2062 mTextureTrace.Reset();
2064 inline TraceCallStack& GetTextureTrace()
2066 return mTextureTrace;
2069 //Methods for Texture verification
2070 inline void EnableTexParameterCallTrace(bool enable)
2072 mTexParamaterTrace.Enable(enable);
2074 inline void ResetTexParameterCallStack()
2076 mTexParamaterTrace.Reset();
2078 inline TraceCallStack& GetTexParameterTrace()
2080 return mTexParamaterTrace;
2083 //Methods for Draw verification
2084 inline void EnableDrawCallTrace(bool enable)
2086 mDrawTrace.Enable(enable);
2088 inline void ResetDrawCallStack()
2092 inline TraceCallStack& GetDrawTrace()
2097 //Methods for Depth function verification
2098 inline void EnableDepthFunctionCallTrace(bool enable)
2100 mDepthFunctionTrace.Enable(enable);
2102 inline void ResetDepthFunctionCallStack()
2104 mDepthFunctionTrace.Reset();
2106 inline TraceCallStack& GetDepthFunctionTrace()
2108 return mDepthFunctionTrace;
2111 //Methods for Stencil function verification
2112 inline void EnableStencilFunctionCallTrace(bool enable)
2114 mStencilFunctionTrace.Enable(enable);
2116 inline void ResetStencilFunctionCallStack()
2118 mStencilFunctionTrace.Reset();
2120 inline TraceCallStack& GetStencilFunctionTrace()
2122 return mStencilFunctionTrace;
2125 //Methods for Scissor verification
2126 inline void EnableScissorCallTrace(bool enable)
2128 mScissorTrace.Enable(enable);
2130 inline void ResetScissorCallStack()
2132 mScissorTrace.Reset();
2134 inline TraceCallStack& GetScissorTrace()
2136 return mScissorTrace;
2139 //Methods for Uniform function verification
2140 inline void EnableSetUniformCallTrace(bool enable)
2142 mSetUniformTrace.Enable(enable);
2144 inline void ResetSetUniformCallStack()
2146 mSetUniformTrace.Reset();
2148 inline TraceCallStack& GetSetUniformTrace()
2150 return mSetUniformTrace;
2153 //Methods for Viewport verification
2154 inline void EnableViewportCallTrace(bool enable)
2156 mViewportTrace.Enable(enable);
2158 inline void ResetViewportCallStack()
2160 mViewportTrace.Reset();
2162 inline TraceCallStack& GetViewportTrace()
2164 return mViewportTrace;
2167 template<typename T>
2168 inline bool GetUniformValue(const char* name, T& value) const
2170 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2171 program_it != mUniforms.end();
2174 const UniformIDMap& uniformIDs = program_it->second;
2176 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2177 if(uniform_it != uniformIDs.end())
2179 // found one matching uniform name, lets check the value...
2180 GLuint programId = program_it->first;
2181 GLint uniformId = uniform_it->second;
2183 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2184 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2190 template<typename T>
2191 inline bool CheckUniformValue(const char* name, const T& value) const
2193 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2194 program_it != mUniforms.end();
2197 const UniformIDMap& uniformIDs = program_it->second;
2199 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2200 if(uniform_it != uniformIDs.end())
2202 // found one matching uniform name, lets check the value...
2203 GLuint programId = program_it->first;
2204 GLint uniformId = uniform_it->second;
2206 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2207 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2209 // the value matches
2215 fprintf(stderr, "Not found, printing possible values:\n");
2216 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2217 program_it != mUniforms.end();
2220 const UniformIDMap& uniformIDs = program_it->second;
2222 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2223 if(uniform_it != uniformIDs.end())
2225 // found one matching uniform name, lets check the value...
2226 GLuint programId = program_it->first;
2227 GLint uniformId = uniform_it->second;
2229 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2231 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2233 std::stringstream out;
2234 out << uniform_it->first << ": " << origValue;
2235 fprintf(stderr, "%s\n", out.str().c_str());
2242 template<typename T>
2243 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2245 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2246 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2249 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2251 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2252 program_it != mUniforms.end();
2255 const UniformIDMap& uniformIDs = program_it->second;
2257 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2258 if(uniform_it != uniformIDs.end())
2260 programId = program_it->first;
2261 uniformId = uniform_it->second;
2268 inline GLuint GetLastShaderCompiled() const
2270 return mLastShaderCompiled;
2273 inline GLuint GetLastProgramCreated() const
2275 return mLastProgramIdUsed;
2278 inline GLbitfield GetLastClearMask() const
2280 return mLastClearBitMask;
2285 ATTRIB_UNKNOWN = -1,
2290 ATTRIB_BONE_WEIGHTS,
2291 ATTRIB_BONE_INDICES,
2295 struct ScissorParams
2311 // Methods to check scissor tests
2312 inline const ScissorParams& GetScissorParams() const
2314 return mScissorParams;
2317 struct ColorMaskParams
2333 inline bool GetProgramBinaryCalled() const
2335 return mGetProgramBinaryCalled;
2338 inline unsigned int GetClearCountCalled() const
2343 inline const ColorMaskParams& GetColorMaskParams() const
2345 return mColorMaskParams;
2348 typedef std::vector<size_t> BufferDataCalls;
2349 inline const BufferDataCalls& GetBufferDataCalls() const
2351 return mBufferDataCalls;
2353 inline void ResetBufferDataCalls()
2355 mBufferDataCalls.clear();
2358 typedef std::vector<size_t> BufferSubDataCalls;
2359 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2361 return mBufferSubDataCalls;
2363 inline void ResetBufferSubDataCalls()
2365 mBufferSubDataCalls.clear();
2369 GLuint mCurrentProgram;
2370 GLuint mCompileStatus;
2371 BufferDataCalls mBufferDataCalls;
2372 BufferSubDataCalls mBufferSubDataCalls;
2374 GLint mNumberOfActiveUniforms;
2375 GLint mGetAttribLocationResult;
2376 GLenum mGetErrorResult;
2377 GLubyte* mGetStringResult;
2378 GLboolean mIsBufferResult;
2379 GLboolean mIsEnabledResult;
2380 GLboolean mIsFramebufferResult;
2381 GLboolean mIsProgramResult;
2382 GLboolean mIsRenderbufferResult;
2383 GLboolean mIsShaderResult;
2384 GLboolean mIsTextureResult;
2385 GLenum mActiveTextureUnit;
2386 GLenum mCheckFramebufferStatusResult;
2387 GLint mFramebufferStatus;
2388 GLenum mFramebufferDepthAttached;
2389 GLenum mFramebufferStencilAttached;
2390 GLuint mFramebufferColorAttachmentCount;
2391 GLuint mFrameBufferColorStatus;
2392 GLint mNumBinaryFormats;
2393 GLint mBinaryFormats;
2394 GLint mProgramBinaryLength;
2395 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2396 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2397 bool mGetProgramBinaryCalled;
2398 typedef std::map<GLuint, std::string> ShaderSourceMap;
2399 ShaderSourceMap mShaderSources;
2400 GLuint mLastShaderCompiled;
2401 GLbitfield mLastClearBitMask;
2402 Vector4 mLastClearColor;
2403 unsigned int mClearCount;
2405 Vector4 mLastBlendColor;
2406 GLenum mLastBlendEquationRgb;
2407 GLenum mLastBlendEquationAlpha;
2408 GLenum mLastBlendFuncSrcRgb;
2409 GLenum mLastBlendFuncDstRgb;
2410 GLenum mLastBlendFuncSrcAlpha;
2411 GLenum mLastBlendFuncDstAlpha;
2413 GLboolean mLastDepthMask;
2415 // Data for manipulating the IDs returned by GenTextures
2416 GLuint mLastAutoTextureIdUsed;
2417 GLuint mNumGeneratedTextures;
2418 std::vector<GLuint> mNextTextureIds;
2419 std::vector<GLuint> mDeletedTextureIds;
2420 std::vector<GLuint> mBoundTextures;
2422 struct ActiveTextureType
2424 std::vector<GLuint> mBoundTextures;
2427 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2429 TraceCallStack mCullFaceTrace;
2430 TraceCallStack mEnableDisableTrace;
2431 TraceCallStack mShaderTrace;
2432 TraceCallStack mTextureTrace;
2433 TraceCallStack mTexParamaterTrace;
2434 TraceCallStack mDrawTrace;
2435 TraceCallStack mDepthFunctionTrace;
2436 TraceCallStack mStencilFunctionTrace;
2437 TraceCallStack mScissorTrace;
2438 TraceCallStack mSetUniformTrace;
2439 TraceCallStack mViewportTrace;
2441 // Shaders & Uniforms
2442 GLuint mLastShaderIdUsed;
2443 GLuint mLastProgramIdUsed;
2444 GLuint mLastUniformIdUsed;
2445 typedef std::map<std::string, GLint> UniformIDMap;
2446 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2447 ProgramUniformMap mUniforms;
2449 template<typename T>
2450 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2453 typedef std::map<GLint, T> UniformValueMap;
2454 typedef std::map<GLuint, UniformValueMap> Map;
2456 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2463 typename Map::iterator it = Map::find(program);
2464 if(it == Map::end())
2466 // if its the first uniform for this program add it
2467 std::pair<typename Map::iterator, bool> result =
2468 Map::insert(typename Map::value_type(program, UniformValueMap()));
2472 UniformValueMap& uniforms = it->second;
2473 uniforms[uniform] = value;
2478 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2481 if(GetUniformValue(program, uniform, uniformValue))
2483 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2489 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2496 typename Map::const_iterator it = Map::find(program);
2497 if(it == Map::end())
2499 // Uniform values always initialised as 0
2504 const UniformValueMap& uniforms = it->second;
2505 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2506 if(it2 == uniforms.end())
2508 // Uniform values always initialised as 0
2512 value = it2->second;
2519 ProgramUniformValue<int> mProgramUniforms1i;
2520 ProgramUniformValue<float> mProgramUniforms1f;
2521 ProgramUniformValue<Vector2> mProgramUniforms2f;
2522 ProgramUniformValue<Vector3> mProgramUniforms3f;
2523 ProgramUniformValue<Vector4> mProgramUniforms4f;
2524 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2525 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2527 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2529 return mProgramUniforms1i;
2531 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2533 return mProgramUniforms1f;
2535 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2537 return mProgramUniforms2f;
2539 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2541 return mProgramUniforms3f;
2543 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2545 return mProgramUniforms4f;
2547 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2549 return mProgramUniformsMat4;
2551 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2553 return mProgramUniformsMat3;
2555 inline void SetVertexAttribArray(GLuint index, bool state)
2557 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2562 mVertexAttribArrayState[index] = state;
2563 mVertexAttribArrayChanged = true;
2566 ScissorParams mScissorParams;
2567 ColorMaskParams mColorMaskParams;
2571 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2577 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2583 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2585 return Vector2::ZERO;
2589 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2591 return Vector3::ZERO;
2595 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2597 return Vector4::ZERO;
2601 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2607 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2609 return Matrix3(Matrix());
2614 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2615 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2617 #endif // TEST_GL_ABSTRACTION_H