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 TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
68 inline void ActiveTexture(GLenum textureUnit) override
70 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
73 inline GLenum GetActiveTextureUnit() const
75 return mActiveTextureUnit + GL_TEXTURE0;
78 inline void AttachShader(GLuint program, GLuint shader) override
80 std::stringstream out;
81 out << program << ", " << shader;
83 TraceCallStack::NamedParams namedParams;
84 namedParams["program"] = ToString(program);
85 namedParams["shader"] = ToString(shader);
86 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
89 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
93 inline void BindBuffer(GLenum target, GLuint buffer) override
97 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
100 mFramebufferStatus |= 2;
103 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
108 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
109 * @return A vector containing the IDs that were bound.
111 inline const std::vector<GLuint>& GetBoundTextures() const
113 return mBoundTextures;
117 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
118 * @param[in] activeTextureUnit The specific active texture unit.
119 * @return A vector containing the IDs that were bound.
121 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
123 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
127 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
129 inline void ClearBoundTextures()
131 mBoundTextures.clear();
133 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
135 mActiveTextures[i].mBoundTextures.clear();
139 inline void BindTexture(GLenum target, GLuint texture) override
141 // Record the bound textures for future checks
144 mBoundTextures.push_back(texture);
146 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
148 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
152 std::stringstream out;
153 out << target << ", " << texture;
155 TraceCallStack::NamedParams namedParams;
156 namedParams["target"] = ToString(target);
157 namedParams["texture"] = ToString(texture);
159 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
162 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
164 mLastBlendColor.r = red;
165 mLastBlendColor.g = green;
166 mLastBlendColor.b = blue;
167 mLastBlendColor.a = alpha;
170 inline const Vector4& GetLastBlendColor() const
172 return mLastBlendColor;
175 inline void BlendEquation(GLenum mode) override
177 mLastBlendEquationRgb = mode;
178 mLastBlendEquationAlpha = mode;
181 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
183 mLastBlendEquationRgb = modeRgb;
184 mLastBlendEquationAlpha = modeAlpha;
187 inline GLenum GetLastBlendEquationRgb() const
189 return mLastBlendEquationRgb;
192 inline GLenum GetLastBlendEquationAlpha() const
194 return mLastBlendEquationAlpha;
197 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
199 mLastBlendFuncSrcRgb = sfactor;
200 mLastBlendFuncDstRgb = dfactor;
201 mLastBlendFuncSrcAlpha = sfactor;
202 mLastBlendFuncDstAlpha = dfactor;
205 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
207 mLastBlendFuncSrcRgb = srcRGB;
208 mLastBlendFuncDstRgb = dstRGB;
209 mLastBlendFuncSrcAlpha = srcAlpha;
210 mLastBlendFuncDstAlpha = dstAlpha;
213 inline GLenum GetLastBlendFuncSrcRgb() const
215 return mLastBlendFuncSrcRgb;
218 inline GLenum GetLastBlendFuncDstRgb() const
220 return mLastBlendFuncDstRgb;
223 inline GLenum GetLastBlendFuncSrcAlpha() const
225 return mLastBlendFuncSrcAlpha;
228 inline GLenum GetLastBlendFuncDstAlpha() const
230 return mLastBlendFuncDstAlpha;
233 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
235 mBufferDataCalls.push_back(size);
238 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
240 mBufferSubDataCalls.push_back(size);
243 inline GLenum CheckFramebufferStatus(GLenum target) override
245 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
246 //Framebuffer texture have been called
247 if(mFramebufferStatus == 7)
249 return GL_FRAMEBUFFER_COMPLETE;
252 return mCheckFramebufferStatusResult;
255 inline GLuint CheckFramebufferColorAttachmentCount()
257 return mFramebufferColorAttachmentCount;
260 inline GLenum CheckFramebufferDepthAttachment()
262 return mFramebufferDepthAttached;
265 inline GLenum CheckFramebufferStencilAttachment()
267 return mFramebufferStencilAttached;
270 inline void Clear(GLbitfield mask) override
273 mLastClearBitMask = mask;
276 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
278 mLastClearColor.r = red;
279 mLastClearColor.g = green;
280 mLastClearColor.b = blue;
281 mLastClearColor.a = alpha;
284 inline const Vector4& GetLastClearColor() const
286 return mLastClearColor;
289 inline void ClearDepthf(GLclampf depth) override
293 inline void ClearStencil(GLint s) override
295 std::stringstream out;
298 TraceCallStack::NamedParams namedParams;
299 namedParams["s"] = ToString(s);
301 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
304 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
306 mColorMaskParams.red = red;
307 mColorMaskParams.green = green;
308 mColorMaskParams.blue = blue;
309 mColorMaskParams.alpha = alpha;
312 inline void CompileShader(GLuint shader) override
314 std::stringstream out;
316 TraceCallStack::NamedParams namedParams;
317 namedParams["shader"] = ToString(shader);
319 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
322 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
324 std::stringstream out;
325 out << target << ", " << level << ", " << width << ", " << height;
327 TraceCallStack::NamedParams namedParams;
328 namedParams["target"] = ToString(target);
329 namedParams["level"] = ToString(level);
330 namedParams["internalformat"] = ToString(internalformat);
331 namedParams["width"] = ToString(width);
332 namedParams["height"] = ToString(height);
333 namedParams["border"] = ToString(border);
334 namedParams["size"] = ToString(imageSize);
336 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
339 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
341 std::stringstream out;
342 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
344 TraceCallStack::NamedParams namedParams;
345 namedParams["target"] = ToString(target);
346 namedParams["level"] = ToString(level);
347 namedParams["xoffset"] = ToString(xoffset);
348 namedParams["yoffset"] = ToString(yoffset);
349 namedParams["width"] = ToString(width);
350 namedParams["height"] = ToString(height);
351 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
354 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
358 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
362 inline GLuint CreateProgram(void) override
364 mShaderTrace.PushCall("CreateProgram", "");
366 ++mLastProgramIdUsed;
367 mUniforms[mLastProgramIdUsed] = UniformIDMap();
368 return mLastProgramIdUsed;
371 inline GLuint CreateShader(GLenum type) override
373 std::stringstream out;
376 TraceCallStack::NamedParams namedParams;
377 namedParams["type"] = ToString(type);
378 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
380 return ++mLastShaderIdUsed;
383 inline void CullFace(GLenum mode) override
385 std::stringstream out;
388 TraceCallStack::NamedParams namedParams;
389 namedParams["program"] = ToString(mode);
391 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
394 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
398 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
402 inline void DeleteProgram(GLuint program) override
404 std::stringstream out;
407 TraceCallStack::NamedParams namedParams;
408 namedParams["program"] = ToString(program);
410 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
413 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
417 inline void DeleteShader(GLuint shader) override
419 std::stringstream out;
422 TraceCallStack::NamedParams namedParams;
423 namedParams["shader"] = ToString(shader);
425 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
428 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
430 std::stringstream out;
431 out << n << ", " << textures << " = [";
433 TraceCallStack::NamedParams namedParams;
435 for(GLsizei i = 0; i < n; i++)
437 out << textures[i] << ", ";
438 std::stringstream paramName;
439 paramName << "texture[" << i << "]";
440 namedParams[paramName.str()] = ToString(textures[i]);
441 mDeletedTextureIds.push_back(textures[i]);
442 mNumGeneratedTextures--;
446 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
449 inline bool CheckNoTexturesDeleted()
451 return mDeletedTextureIds.size() == 0;
454 inline bool CheckTextureDeleted(GLuint textureId)
458 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
460 if(*iter == textureId)
469 inline void ClearDeletedTextures()
471 mDeletedTextureIds.clear();
474 inline void DepthFunc(GLenum func) override
476 std::stringstream out;
479 TraceCallStack::NamedParams namedParams;
480 namedParams["func"] = ToString(func);
482 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
485 inline void DepthMask(GLboolean flag) override
487 mLastDepthMask = flag;
490 inline bool GetLastDepthMask() const
492 return mLastDepthMask;
495 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
499 inline void DetachShader(GLuint program, GLuint shader) override
501 std::stringstream out;
502 out << program << ", " << shader;
503 TraceCallStack::NamedParams namedParams;
504 namedParams["program"] = ToString(program);
505 namedParams["shader"] = ToString(shader);
506 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
509 inline void Disable(GLenum cap) override
511 std::stringstream out;
513 TraceCallStack::NamedParams namedParams;
514 namedParams["cap"] = ToString(cap);
515 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
518 inline void DisableVertexAttribArray(GLuint index) override
520 SetVertexAttribArray(index, false);
523 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
525 std::stringstream out;
526 out << mode << ", " << first << ", " << count;
527 TraceCallStack::NamedParams namedParams;
528 namedParams["mode"] = ToString(mode);
529 namedParams["first"] = ToString(first);
530 namedParams["count"] = ToString(count);
531 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
534 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
536 std::stringstream out;
537 out << mode << ", " << count << ", " << type << ", indices";
539 TraceCallStack::NamedParams namedParams;
540 namedParams["mode"] = ToString(mode);
541 namedParams["count"] = ToString(count);
542 namedParams["type"] = ToString(type);
543 // Skip void pointers - are they of any use?
544 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
547 inline void Enable(GLenum cap) override
549 std::stringstream out;
551 TraceCallStack::NamedParams namedParams;
552 namedParams["cap"] = ToString(cap);
553 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
556 inline void EnableVertexAttribArray(GLuint index) override
558 SetVertexAttribArray(index, true);
561 inline void Finish(void) override
565 inline void Flush(void) override
569 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
571 if(attachment == GL_DEPTH_ATTACHMENT)
573 mFramebufferDepthAttached = true;
575 else if(attachment == GL_STENCIL_ATTACHMENT)
577 mFramebufferStencilAttached = true;
581 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
584 mFramebufferStatus |= 4;
586 //We check 4 attachment colors
587 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
589 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
590 if((mFrameBufferColorStatus & mask) == 0)
592 mFrameBufferColorStatus |= mask;
593 ++mFramebufferColorAttachmentCount;
598 inline void FrontFace(GLenum mode) override
602 inline void GenBuffers(GLsizei n, GLuint* buffers) override
604 // avoids an assert in GpuBuffers
608 inline void GenerateMipmap(GLenum target) override
610 std::stringstream out;
612 TraceCallStack::NamedParams namedParams;
613 namedParams["target"] = ToString(target);
615 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
618 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
620 for(int i = 0; i < n; i++)
622 framebuffers[i] = i + 1;
625 //Add 001 bit, this function needs to be called the first one in the chain
626 mFramebufferStatus = 1;
629 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
631 for(int i = 0; i < n; i++)
633 renderbuffers[i] = i + 1;
638 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
639 * @param[in] ids A vector containing the next IDs to be generated
641 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
643 mNextTextureIds = ids;
646 inline const std::vector<GLuint>& GetNextTextureIds()
648 return mNextTextureIds;
651 inline void GenTextures(GLsizei count, GLuint* textures) override
653 for(int i = 0; i < count; ++i)
655 if(!mNextTextureIds.empty())
657 *(textures + i) = mNextTextureIds[0];
658 mNextTextureIds.erase(mNextTextureIds.begin());
662 *(textures + i) = ++mLastAutoTextureIdUsed;
664 mNumGeneratedTextures++;
667 TraceCallStack::NamedParams namedParams;
668 namedParams["count"] = ToString(count);
670 std::stringstream out;
671 for(int i = 0; i < count; i++)
678 std::ostringstream oss;
679 oss << "indices[" << i << "]";
680 namedParams[oss.str()] = ToString(textures[i]);
683 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
686 inline GLuint GetLastGenTextureId()
688 return mLastAutoTextureIdUsed;
691 inline GLuint GetNumGeneratedTextures()
693 return mNumGeneratedTextures;
696 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
700 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
705 *length = snprintf(name, bufsize, "sTexture");
706 *type = GL_SAMPLER_2D;
710 *length = snprintf(name, bufsize, "sEffect");
711 *type = GL_SAMPLER_2D;
715 *length = snprintf(name, bufsize, "sGloss");
716 *type = GL_SAMPLER_2D;
724 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
728 inline int GetAttribLocation(GLuint program, const char* name) override
730 std::string attribName(name);
732 for(unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i)
734 if(mStdAttribs[i] == attribName)
740 // 0 is a valid location
744 inline void GetBooleanv(GLenum pname, GLboolean* params) override
748 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
752 inline GLenum GetError(void) override
754 return mGetErrorResult;
757 inline void GetFloatv(GLenum pname, GLfloat* params) override
761 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
765 inline void GetIntegerv(GLenum pname, GLint* params) override
769 case GL_MAX_TEXTURE_SIZE:
772 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
775 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
776 *params = mNumBinaryFormats;
778 case GL_PROGRAM_BINARY_FORMATS_OES:
779 *params = mBinaryFormats;
784 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
789 *params = mLinkStatus;
791 case GL_PROGRAM_BINARY_LENGTH_OES:
792 *params = mProgramBinaryLength;
794 case GL_ACTIVE_UNIFORMS:
795 *params = mNumberOfActiveUniforms;
797 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
803 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
807 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
811 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
815 case GL_COMPILE_STATUS:
816 *params = mCompileStatus;
821 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
825 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
829 inline const GLubyte* GetString(GLenum name) override
831 return mGetStringResult;
834 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
838 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
842 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
846 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
850 inline GLint GetUniformLocation(GLuint program, const char* name) override
852 ProgramUniformMap::iterator it = mUniforms.find(program);
853 if(it == mUniforms.end())
855 // Not a valid program ID
856 mGetErrorResult = GL_INVALID_OPERATION;
860 UniformIDMap& uniformIDs = it->second;
861 UniformIDMap::iterator it2 = uniformIDs.find(name);
862 if(it2 == uniformIDs.end())
864 // Uniform not found, so add it...
865 uniformIDs[name] = ++mLastUniformIdUsed;
866 return mLastUniformIdUsed;
872 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
876 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
880 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
884 inline void Hint(GLenum target, GLenum mode) override
888 inline GLboolean IsBuffer(GLuint buffer) override
890 return mIsBufferResult;
893 inline GLboolean IsEnabled(GLenum cap) override
895 return mIsEnabledResult;
898 inline GLboolean IsFramebuffer(GLuint framebuffer) override
900 return mIsFramebufferResult;
903 inline GLboolean IsProgram(GLuint program) override
905 return mIsProgramResult;
908 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
910 return mIsRenderbufferResult;
913 inline GLboolean IsShader(GLuint shader) override
915 return mIsShaderResult;
918 inline GLboolean IsTexture(GLuint texture) override
920 return mIsTextureResult;
923 inline void LineWidth(GLfloat width) override
927 inline void LinkProgram(GLuint program) override
929 std::stringstream out;
932 TraceCallStack::NamedParams namedParams;
933 namedParams["program"] = ToString(program);
934 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
936 mNumberOfActiveUniforms = 3;
937 GetUniformLocation(program, "sTexture");
938 GetUniformLocation(program, "sEffect");
939 GetUniformLocation(program, "sGloss");
942 inline void PixelStorei(GLenum pname, GLint param) override
946 inline void PolygonOffset(GLfloat factor, GLfloat units) override
950 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
954 inline void ReleaseShaderCompiler(void) override
958 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
962 inline void SampleCoverage(GLclampf value, GLboolean invert) override
966 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
968 mScissorParams.x = x;
969 mScissorParams.y = y;
970 mScissorParams.width = width;
971 mScissorParams.height = height;
973 std::stringstream out;
974 out << x << ", " << y << ", " << width << ", " << height;
975 TraceCallStack::NamedParams namedParams;
976 namedParams["x"] = ToString(x);
977 namedParams["y"] = ToString(y);
978 namedParams["width"] = ToString(width);
979 namedParams["height"] = ToString(height);
980 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
983 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
987 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
989 std::string stringBuilder;
990 for(int i = 0; i < count; ++i)
992 stringBuilder += string[i];
994 mShaderSources[shader] = stringBuilder;
995 mLastShaderCompiled = shader;
998 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1000 const std::string shaderSource = mShaderSources[shader];
1001 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1002 if(shaderSourceLength < bufsize)
1004 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1005 *length = shaderSourceLength;
1009 *length = bufsize - 1;
1010 strncpy(source, shaderSource.c_str(), *length);
1011 source[*length] = 0x0;
1015 inline std::string GetShaderSource(GLuint shader)
1017 return mShaderSources[shader];
1020 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1022 std::stringstream out;
1023 out << func << ", " << ref << ", " << mask;
1025 TraceCallStack::NamedParams namedParams;
1026 namedParams["func"] = ToString(func);
1027 namedParams["ref"] = ToString(ref);
1028 namedParams["mask"] = ToString(mask);
1030 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1033 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1035 std::stringstream out;
1036 out << face << ", " << func << ", " << ref << ", " << mask;
1038 TraceCallStack::NamedParams namedParams;
1039 namedParams["face"] = ToString(face);
1040 namedParams["func"] = ToString(func);
1041 namedParams["ref"] = ToString(ref);
1042 namedParams["mask"] = ToString(mask);
1044 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1047 inline void StencilMask(GLuint mask) override
1049 std::stringstream out;
1052 TraceCallStack::NamedParams namedParams;
1053 namedParams["mask"] = ToString(mask);
1055 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1058 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1060 std::stringstream out;
1061 out << face << ", " << mask;
1063 TraceCallStack::NamedParams namedParams;
1064 namedParams["face"] = ToString(face);
1065 namedParams["mask"] = ToString(mask);
1067 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1070 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1072 std::stringstream out;
1073 out << fail << ", " << zfail << ", " << zpass;
1075 TraceCallStack::NamedParams namedParams;
1076 namedParams["fail"] = ToString(fail);
1077 namedParams["zfail"] = ToString(zfail);
1078 namedParams["zpass"] = ToString(zpass);
1080 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1083 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1085 std::stringstream out;
1086 out << face << ", " << fail << ", " << zfail << "," << zpass;
1088 TraceCallStack::NamedParams namedParams;
1089 namedParams["face"] = ToString(face);
1090 namedParams["fail"] = ToString(fail);
1091 namedParams["zfail"] = ToString(zfail);
1092 namedParams["zpass"] = ToString(zpass);
1094 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1097 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1099 std::stringstream out;
1100 out << target << ", " << level << ", " << width << ", " << height;
1102 TraceCallStack::NamedParams namedParams;
1103 namedParams["target"] = ToString(target);
1104 namedParams["level"] = ToString(level);
1105 namedParams["internalformat"] = ToString(internalformat);
1106 namedParams["width"] = ToString(width);
1107 namedParams["height"] = ToString(height);
1108 namedParams["border"] = ToString(border);
1109 namedParams["format"] = ToString(format);
1110 namedParams["type"] = ToString(type);
1112 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1115 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1117 std::stringstream out;
1118 out << target << ", " << pname << ", " << param;
1120 TraceCallStack::NamedParams namedParams;
1121 namedParams["target"] = ToString(target);
1122 namedParams["pname"] = ToString(pname);
1123 namedParams["param"] = ToString(param);
1125 mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
1128 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1130 std::stringstream out;
1131 out << target << ", " << pname << ", " << params[0];
1133 TraceCallStack::NamedParams namedParams;
1134 namedParams["target"] = ToString(target);
1135 namedParams["pname"] = ToString(pname);
1136 namedParams["params[0]"] = ToString(params[0]);
1138 mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1141 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1143 std::stringstream out;
1144 out << target << ", " << pname << ", " << param;
1145 TraceCallStack::NamedParams namedParams;
1146 namedParams["target"] = ToString(target);
1147 namedParams["pname"] = ToString(pname);
1148 namedParams["param"] = ToString(param);
1149 mTexParamaterTrace.PushCall("TexParameteri", out.str(), namedParams);
1152 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1154 std::stringstream out;
1155 out << target << ", " << pname << ", " << params[0];
1156 TraceCallStack::NamedParams namedParams;
1157 namedParams["target"] = ToString(target);
1158 namedParams["pname"] = ToString(pname);
1159 namedParams["params[0]"] = ToString(params[0]);
1160 mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1163 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1165 std::stringstream out;
1166 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1168 TraceCallStack::NamedParams namedParams;
1169 namedParams["target"] = ToString(target);
1170 namedParams["level"] = ToString(level);
1171 namedParams["xoffset"] = ToString(xoffset);
1172 namedParams["yoffset"] = ToString(yoffset);
1173 namedParams["width"] = ToString(width);
1174 namedParams["height"] = ToString(height);
1175 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1178 inline void Uniform1f(GLint location, GLfloat value) override
1180 std::string params = ToString(value);
1181 AddUniformCallToTraceStack(location, params);
1183 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1185 mGetErrorResult = GL_INVALID_OPERATION;
1189 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1192 for(int i = 0; i < count; ++i)
1194 params = params + ToString(v[i]) + ",";
1197 AddUniformCallToTraceStack(location, params);
1199 for(int i = 0; i < count; ++i)
1201 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1203 mGetErrorResult = GL_INVALID_OPERATION;
1209 inline void Uniform1i(GLint location, GLint x) override
1211 std::string params = ToString(x);
1213 AddUniformCallToTraceStack(location, params);
1215 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1217 mGetErrorResult = GL_INVALID_OPERATION;
1221 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1223 std::string params = ToString(v);
1224 AddUniformCallToTraceStack(location, params);
1226 for(int i = 0; i < count; ++i)
1228 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1232 mGetErrorResult = GL_INVALID_OPERATION;
1238 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1240 std::string params = ToString(x) + "," + ToString(y);
1241 AddUniformCallToTraceStack(location, params);
1243 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1247 mGetErrorResult = GL_INVALID_OPERATION;
1251 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1253 std::string params = ToString(v);
1254 AddUniformCallToTraceStack(location, params);
1256 for(int i = 0; i < count; ++i)
1258 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1260 Vector2(v[2 * i], v[2 * i + 1])))
1262 mGetErrorResult = GL_INVALID_OPERATION;
1268 inline void Uniform2i(GLint location, GLint x, GLint y) override
1270 std::string params = ToString(x) + "," + ToString(y);
1271 AddUniformCallToTraceStack(location, params);
1274 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1276 std::string params = ToString(v);
1277 AddUniformCallToTraceStack(location, params);
1280 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1282 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1283 AddUniformCallToTraceStack(location, params);
1285 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1289 mGetErrorResult = GL_INVALID_OPERATION;
1293 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1295 std::string params = ToString(v);
1296 AddUniformCallToTraceStack(location, params);
1298 for(int i = 0; i < count; ++i)
1300 if(!mProgramUniforms3f.SetUniformValue(
1303 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1305 mGetErrorResult = GL_INVALID_OPERATION;
1311 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1313 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
1314 AddUniformCallToTraceStack(location, params);
1317 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1319 std::string params = ToString(v);
1320 AddUniformCallToTraceStack(location, params);
1323 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1325 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1326 AddUniformCallToTraceStack(location, params);
1328 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1330 Vector4(x, y, z, w)))
1332 mGetErrorResult = GL_INVALID_OPERATION;
1336 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1338 std::string params = ToString(v);
1339 AddUniformCallToTraceStack(location, params);
1341 for(int i = 0; i < count; ++i)
1343 if(!mProgramUniforms4f.SetUniformValue(
1346 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1348 mGetErrorResult = GL_INVALID_OPERATION;
1354 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1356 std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
1357 AddUniformCallToTraceStack(location, params);
1360 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1362 std::string params = ToString(v);
1363 AddUniformCallToTraceStack(location, params);
1366 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1368 std::string params = ToString(value);
1369 AddUniformCallToTraceStack(location, params);
1372 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1374 std::string params = ToString(value);
1375 AddUniformCallToTraceStack(location, params);
1377 for(int i = 0; i < count; ++i)
1379 if(!mProgramUniformsMat3.SetUniformValue(
1382 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1384 mGetErrorResult = GL_INVALID_OPERATION;
1390 inline void UniformMatrix4fv(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(!mProgramUniformsMat4.SetUniformValue(
1402 mGetErrorResult = GL_INVALID_OPERATION;
1408 inline void UseProgram(GLuint program) override
1410 mCurrentProgram = program;
1413 inline void ValidateProgram(GLuint program) override
1417 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1421 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1425 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1429 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1433 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1437 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1441 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1445 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1449 inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1453 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1455 std::string commaString(", ");
1456 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1458 mViewportTrace.PushCall("Viewport", params);
1463 inline void ReadBuffer(GLenum mode) override
1467 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1471 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
1475 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
1479 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1483 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1487 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
1491 inline void GenQueries(GLsizei n, GLuint* ids) override
1495 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1499 inline GLboolean IsQuery(GLuint id) override
1504 inline void BeginQuery(GLenum target, GLuint id) override
1508 inline void EndQuery(GLenum target) override
1512 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1516 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1520 inline GLboolean UnmapBuffer(GLenum target) override
1525 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1529 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1533 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1537 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1541 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1545 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1549 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1553 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1557 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1561 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1565 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1569 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1574 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1578 inline void BindVertexArray(GLuint array) override
1582 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1586 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1590 inline GLboolean IsVertexArray(GLuint array) override
1595 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1599 inline void BeginTransformFeedback(GLenum primitiveMode) override
1603 inline void EndTransformFeedback(void) override
1607 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1611 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1615 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1619 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1623 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1627 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1631 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1635 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1639 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1643 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1647 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1651 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1655 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1660 inline void Uniform1ui(GLint location, GLuint v0) override
1664 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1668 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1672 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1676 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1680 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1684 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1688 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1692 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1696 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1700 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1704 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1708 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1713 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1717 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1721 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1725 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1727 return GL_INVALID_INDEX;
1730 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1734 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1738 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1742 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1746 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1750 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1755 inline GLboolean IsSync(GLsync sync) override
1760 inline void DeleteSync(GLsync sync) override
1764 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1769 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1773 inline void GetInteger64v(GLenum pname, GLint64* params) override
1777 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1781 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1785 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1789 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1793 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1797 inline GLboolean IsSampler(GLuint sampler) override
1802 inline void BindSampler(GLuint unit, GLuint sampler) override
1806 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1810 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1814 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1818 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1822 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1826 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1830 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1834 inline void BindTransformFeedback(GLenum target, GLuint id) override
1838 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1842 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1846 inline GLboolean IsTransformFeedback(GLuint id) override
1851 inline void PauseTransformFeedback(void) override
1855 inline void ResumeTransformFeedback(void) override
1859 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1861 mGetProgramBinaryCalled = true;
1864 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1868 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1872 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1876 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1880 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1884 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1888 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1893 inline void AddUniformCallToTraceStack(GLint location, std::string& value)
1895 std::string name = "<not found>";
1896 bool matched = false;
1898 UniformIDMap& map = mUniforms[mCurrentProgram];
1899 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
1901 if(it->second == location)
1911 mSetUniformTrace.PushCall(name, value);
1915 public: // TEST FUNCTIONS
1916 inline void SetCompileStatus(GLuint value)
1918 mCompileStatus = value;
1920 inline void SetLinkStatus(GLuint value)
1922 mLinkStatus = value;
1924 inline void SetGetAttribLocationResult(int result)
1926 mGetAttribLocationResult = result;
1928 inline void SetGetErrorResult(GLenum result)
1930 mGetErrorResult = result;
1932 inline void SetGetStringResult(GLubyte* result)
1934 mGetStringResult = result;
1936 inline void SetIsBufferResult(GLboolean result)
1938 mIsBufferResult = result;
1940 inline void SetIsEnabledResult(GLboolean result)
1942 mIsEnabledResult = result;
1944 inline void SetIsFramebufferResult(GLboolean result)
1946 mIsFramebufferResult = result;
1948 inline void SetIsProgramResult(GLboolean result)
1950 mIsProgramResult = result;
1952 inline void SetIsRenderbufferResult(GLboolean result)
1954 mIsRenderbufferResult = result;
1956 inline void SetIsShaderResult(GLboolean result)
1958 mIsShaderResult = result;
1960 inline void SetIsTextureResult(GLboolean result)
1962 mIsTextureResult = result;
1964 inline void SetCheckFramebufferStatusResult(GLenum result)
1966 mCheckFramebufferStatusResult = result;
1968 inline void SetNumBinaryFormats(GLint numFormats)
1970 mNumBinaryFormats = numFormats;
1972 inline void SetBinaryFormats(GLint binaryFormats)
1974 mBinaryFormats = binaryFormats;
1976 inline void SetProgramBinaryLength(GLint length)
1978 mProgramBinaryLength = length;
1981 inline bool GetVertexAttribArrayState(GLuint index)
1983 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
1988 return mVertexAttribArrayState[index];
1990 inline void ClearVertexAttribArrayChanged()
1992 mVertexAttribArrayChanged = false;
1994 inline bool GetVertexAttribArrayChanged()
1996 return mVertexAttribArrayChanged;
1999 //Methods for CullFace verification
2000 inline void EnableCullFaceCallTrace(bool enable)
2002 mCullFaceTrace.Enable(enable);
2004 inline void ResetCullFaceCallStack()
2006 mCullFaceTrace.Reset();
2008 inline TraceCallStack& GetCullFaceTrace()
2010 return mCullFaceTrace;
2013 //Methods for Enable/Disable call verification
2014 inline void EnableEnableDisableCallTrace(bool enable)
2016 mEnableDisableTrace.Enable(enable);
2018 inline void ResetEnableDisableCallStack()
2020 mEnableDisableTrace.Reset();
2022 inline TraceCallStack& GetEnableDisableTrace()
2024 return mEnableDisableTrace;
2027 //Methods for Shader verification
2028 inline void EnableShaderCallTrace(bool enable)
2030 mShaderTrace.Enable(enable);
2032 inline void ResetShaderCallStack()
2034 mShaderTrace.Reset();
2036 inline TraceCallStack& GetShaderTrace()
2038 return mShaderTrace;
2041 //Methods for Texture verification
2042 inline void EnableTextureCallTrace(bool enable)
2044 mTextureTrace.Enable(enable);
2046 inline void ResetTextureCallStack()
2048 mTextureTrace.Reset();
2050 inline TraceCallStack& GetTextureTrace()
2052 return mTextureTrace;
2055 //Methods for Texture verification
2056 inline void EnableTexParameterCallTrace(bool enable)
2058 mTexParamaterTrace.Enable(enable);
2060 inline void ResetTexParameterCallStack()
2062 mTexParamaterTrace.Reset();
2064 inline TraceCallStack& GetTexParameterTrace()
2066 return mTexParamaterTrace;
2069 //Methods for Draw verification
2070 inline void EnableDrawCallTrace(bool enable)
2072 mDrawTrace.Enable(enable);
2074 inline void ResetDrawCallStack()
2078 inline TraceCallStack& GetDrawTrace()
2083 //Methods for Depth function verification
2084 inline void EnableDepthFunctionCallTrace(bool enable)
2086 mDepthFunctionTrace.Enable(enable);
2088 inline void ResetDepthFunctionCallStack()
2090 mDepthFunctionTrace.Reset();
2092 inline TraceCallStack& GetDepthFunctionTrace()
2094 return mDepthFunctionTrace;
2097 //Methods for Stencil function verification
2098 inline void EnableStencilFunctionCallTrace(bool enable)
2100 mStencilFunctionTrace.Enable(enable);
2102 inline void ResetStencilFunctionCallStack()
2104 mStencilFunctionTrace.Reset();
2106 inline TraceCallStack& GetStencilFunctionTrace()
2108 return mStencilFunctionTrace;
2111 //Methods for Scissor verification
2112 inline void EnableScissorCallTrace(bool enable)
2114 mScissorTrace.Enable(enable);
2116 inline void ResetScissorCallStack()
2118 mScissorTrace.Reset();
2120 inline TraceCallStack& GetScissorTrace()
2122 return mScissorTrace;
2125 //Methods for Uniform function verification
2126 inline void EnableSetUniformCallTrace(bool enable)
2128 mSetUniformTrace.Enable(enable);
2130 inline void ResetSetUniformCallStack()
2132 mSetUniformTrace.Reset();
2134 inline TraceCallStack& GetSetUniformTrace()
2136 return mSetUniformTrace;
2139 //Methods for Viewport verification
2140 inline void EnableViewportCallTrace(bool enable)
2142 mViewportTrace.Enable(enable);
2144 inline void ResetViewportCallStack()
2146 mViewportTrace.Reset();
2148 inline TraceCallStack& GetViewportTrace()
2150 return mViewportTrace;
2153 template<typename T>
2154 inline bool GetUniformValue(const char* name, T& value) const
2156 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2157 program_it != mUniforms.end();
2160 const UniformIDMap& uniformIDs = program_it->second;
2162 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2163 if(uniform_it != uniformIDs.end())
2165 // found one matching uniform name, lets check the value...
2166 GLuint programId = program_it->first;
2167 GLint uniformId = uniform_it->second;
2169 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2170 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2176 template<typename T>
2177 inline bool CheckUniformValue(const char* name, const T& value) const
2179 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2180 program_it != mUniforms.end();
2183 const UniformIDMap& uniformIDs = program_it->second;
2185 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2186 if(uniform_it != uniformIDs.end())
2188 // found one matching uniform name, lets check the value...
2189 GLuint programId = program_it->first;
2190 GLint uniformId = uniform_it->second;
2192 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2193 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2195 // the value matches
2201 fprintf(stderr, "Not found, printing possible values:\n");
2202 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2203 program_it != mUniforms.end();
2206 const UniformIDMap& uniformIDs = program_it->second;
2208 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2209 if(uniform_it != uniformIDs.end())
2211 // found one matching uniform name, lets check the value...
2212 GLuint programId = program_it->first;
2213 GLint uniformId = uniform_it->second;
2215 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2217 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2219 std::stringstream out;
2220 out << uniform_it->first << ": " << origValue;
2221 fprintf(stderr, "%s\n", out.str().c_str());
2228 template<typename T>
2229 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2231 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2232 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2235 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2237 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2238 program_it != mUniforms.end();
2241 const UniformIDMap& uniformIDs = program_it->second;
2243 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2244 if(uniform_it != uniformIDs.end())
2246 programId = program_it->first;
2247 uniformId = uniform_it->second;
2254 inline GLuint GetLastShaderCompiled() const
2256 return mLastShaderCompiled;
2259 inline GLuint GetLastProgramCreated() const
2261 return mLastProgramIdUsed;
2264 inline GLbitfield GetLastClearMask() const
2266 return mLastClearBitMask;
2271 ATTRIB_UNKNOWN = -1,
2276 ATTRIB_BONE_WEIGHTS,
2277 ATTRIB_BONE_INDICES,
2281 struct ScissorParams
2297 // Methods to check scissor tests
2298 inline const ScissorParams& GetScissorParams() const
2300 return mScissorParams;
2303 struct ColorMaskParams
2319 inline bool GetProgramBinaryCalled() const
2321 return mGetProgramBinaryCalled;
2324 inline unsigned int GetClearCountCalled() const
2329 inline const ColorMaskParams& GetColorMaskParams() const
2331 return mColorMaskParams;
2334 typedef std::vector<size_t> BufferDataCalls;
2335 inline const BufferDataCalls& GetBufferDataCalls() const
2337 return mBufferDataCalls;
2339 inline void ResetBufferDataCalls()
2341 mBufferDataCalls.clear();
2344 typedef std::vector<size_t> BufferSubDataCalls;
2345 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2347 return mBufferSubDataCalls;
2349 inline void ResetBufferSubDataCalls()
2351 mBufferSubDataCalls.clear();
2355 GLuint mCurrentProgram;
2356 GLuint mCompileStatus;
2357 BufferDataCalls mBufferDataCalls;
2358 BufferSubDataCalls mBufferSubDataCalls;
2360 GLint mNumberOfActiveUniforms;
2361 GLint mGetAttribLocationResult;
2362 GLenum mGetErrorResult;
2363 GLubyte* mGetStringResult;
2364 GLboolean mIsBufferResult;
2365 GLboolean mIsEnabledResult;
2366 GLboolean mIsFramebufferResult;
2367 GLboolean mIsProgramResult;
2368 GLboolean mIsRenderbufferResult;
2369 GLboolean mIsShaderResult;
2370 GLboolean mIsTextureResult;
2371 GLenum mActiveTextureUnit;
2372 GLenum mCheckFramebufferStatusResult;
2373 GLint mFramebufferStatus;
2374 GLenum mFramebufferDepthAttached;
2375 GLenum mFramebufferStencilAttached;
2376 GLuint mFramebufferColorAttachmentCount;
2377 GLuint mFrameBufferColorStatus;
2378 GLint mNumBinaryFormats;
2379 GLint mBinaryFormats;
2380 GLint mProgramBinaryLength;
2381 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2382 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2383 bool mGetProgramBinaryCalled;
2384 typedef std::map<GLuint, std::string> ShaderSourceMap;
2385 ShaderSourceMap mShaderSources;
2386 GLuint mLastShaderCompiled;
2387 GLbitfield mLastClearBitMask;
2388 Vector4 mLastClearColor;
2389 unsigned int mClearCount;
2391 Vector4 mLastBlendColor;
2392 GLenum mLastBlendEquationRgb;
2393 GLenum mLastBlendEquationAlpha;
2394 GLenum mLastBlendFuncSrcRgb;
2395 GLenum mLastBlendFuncDstRgb;
2396 GLenum mLastBlendFuncSrcAlpha;
2397 GLenum mLastBlendFuncDstAlpha;
2399 GLboolean mLastDepthMask;
2401 // Data for manipulating the IDs returned by GenTextures
2402 GLuint mLastAutoTextureIdUsed;
2403 GLuint mNumGeneratedTextures;
2404 std::vector<GLuint> mNextTextureIds;
2405 std::vector<GLuint> mDeletedTextureIds;
2406 std::vector<GLuint> mBoundTextures;
2408 struct ActiveTextureType
2410 std::vector<GLuint> mBoundTextures;
2413 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2415 TraceCallStack mCullFaceTrace;
2416 TraceCallStack mEnableDisableTrace;
2417 TraceCallStack mShaderTrace;
2418 TraceCallStack mTextureTrace;
2419 TraceCallStack mTexParamaterTrace;
2420 TraceCallStack mDrawTrace;
2421 TraceCallStack mDepthFunctionTrace;
2422 TraceCallStack mStencilFunctionTrace;
2423 TraceCallStack mScissorTrace;
2424 TraceCallStack mSetUniformTrace;
2425 TraceCallStack mViewportTrace;
2427 // Shaders & Uniforms
2428 GLuint mLastShaderIdUsed;
2429 GLuint mLastProgramIdUsed;
2430 GLuint mLastUniformIdUsed;
2431 typedef std::map<std::string, GLint> UniformIDMap;
2432 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2433 ProgramUniformMap mUniforms;
2435 template<typename T>
2436 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2439 typedef std::map<GLint, T> UniformValueMap;
2440 typedef std::map<GLuint, UniformValueMap> Map;
2442 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2449 typename Map::iterator it = Map::find(program);
2450 if(it == Map::end())
2452 // if its the first uniform for this program add it
2453 std::pair<typename Map::iterator, bool> result =
2454 Map::insert(typename Map::value_type(program, UniformValueMap()));
2458 UniformValueMap& uniforms = it->second;
2459 uniforms[uniform] = value;
2464 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2467 if(GetUniformValue(program, uniform, uniformValue))
2469 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2475 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2482 typename Map::const_iterator it = Map::find(program);
2483 if(it == Map::end())
2485 // Uniform values always initialised as 0
2490 const UniformValueMap& uniforms = it->second;
2491 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2492 if(it2 == uniforms.end())
2494 // Uniform values always initialised as 0
2498 value = it2->second;
2505 ProgramUniformValue<int> mProgramUniforms1i;
2506 ProgramUniformValue<float> mProgramUniforms1f;
2507 ProgramUniformValue<Vector2> mProgramUniforms2f;
2508 ProgramUniformValue<Vector3> mProgramUniforms3f;
2509 ProgramUniformValue<Vector4> mProgramUniforms4f;
2510 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2511 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2513 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2515 return mProgramUniforms1i;
2517 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2519 return mProgramUniforms1f;
2521 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2523 return mProgramUniforms2f;
2525 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2527 return mProgramUniforms3f;
2529 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2531 return mProgramUniforms4f;
2533 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2535 return mProgramUniformsMat4;
2537 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2539 return mProgramUniformsMat3;
2541 inline void SetVertexAttribArray(GLuint index, bool state)
2543 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2548 mVertexAttribArrayState[index] = state;
2549 mVertexAttribArrayChanged = true;
2552 ScissorParams mScissorParams;
2553 ColorMaskParams mColorMaskParams;
2557 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2563 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2569 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2571 return Vector2::ZERO;
2575 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2577 return Vector3::ZERO;
2581 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2583 return Vector4::ZERO;
2587 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2593 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2595 return Matrix3(Matrix());
2600 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2601 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2603 #endif // TEST_GL_ABSTRACTION_H