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.
27 #include <cstring> // for strcmp
31 #include <dali/public-api/dali-core.h>
32 #include <dali/devel-api/rendering/frame-buffer-devel.h>
33 #include <dali/integration-api/core.h>
34 #include <dali/integration-api/gl-abstraction.h>
35 #include <dali/integration-api/gl-defines.h>
36 #include <test-trace-call-stack.h>
37 #include <test-compare-types.h>
42 static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 64;
43 static const char *mStdAttribs[MAX_ATTRIBUTE_CACHE_SIZE] =
45 "aPosition", // ATTRIB_POSITION
46 "aNormal", // ATTRIB_NORMAL
47 "aTexCoord", // ATTRIB_TEXCOORD
48 "aColor", // ATTRIB_COLOR
49 "aBoneWeights", // ATTRIB_BONE_WEIGHTS
50 "aBoneIndices" // ATTRIB_BONE_INDICES
53 class DALI_CORE_API TestGlAbstraction: public Dali::Integration::GlAbstraction
57 ~TestGlAbstraction() override;
60 void PreRender() override;
61 void PostRender() override;
63 bool IsSurfacelessContextSupported() const override;
65 bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const override;
69 inline void ActiveTexture( GLenum textureUnit ) override
71 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
74 inline GLenum GetActiveTextureUnit() const
76 return mActiveTextureUnit + GL_TEXTURE0;
79 inline void AttachShader( GLuint program, GLuint shader ) override
81 std::stringstream out;
82 out << program << ", " << shader;
84 TraceCallStack::NamedParams namedParams;
85 namedParams["program"] = ToString(program);
86 namedParams["shader"] = ToString(shader);
87 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
90 inline void BindAttribLocation( GLuint program, GLuint index, const char* name ) override
94 inline void BindBuffer( GLenum target, GLuint buffer ) override
98 inline void BindFramebuffer( GLenum target, GLuint framebuffer ) override
101 mFramebufferStatus |= 2;
104 inline void BindRenderbuffer( GLenum target, GLuint renderbuffer ) override
109 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
110 * @return A vector containing the IDs that were bound.
112 inline const std::vector<GLuint>& GetBoundTextures() const
114 return mBoundTextures;
118 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
119 * @param[in] activeTextureUnit The specific active texture unit.
120 * @return A vector containing the IDs that were bound.
122 inline const std::vector<GLuint>& GetBoundTextures( GLuint activeTextureUnit ) const
124 return mActiveTextures[ activeTextureUnit - GL_TEXTURE0 ].mBoundTextures;
128 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
130 inline void ClearBoundTextures()
132 mBoundTextures.clear();
134 for( unsigned int i=0; i<MIN_TEXTURE_UNIT_LIMIT; ++i )
136 mActiveTextures[ i ].mBoundTextures.clear();
140 inline void BindTexture( GLenum target, GLuint texture ) override
142 // Record the bound textures for future checks
145 mBoundTextures.push_back( texture );
147 if( mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT )
149 mActiveTextures[ mActiveTextureUnit ].mBoundTextures.push_back( texture );
153 std::stringstream out;
154 out << target << ", " << texture;
156 TraceCallStack::NamedParams namedParams;
157 namedParams["target"] = ToString(target);
158 namedParams["texture"] = ToString(texture);
160 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
163 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
165 mLastBlendColor.r = red;
166 mLastBlendColor.g = green;
167 mLastBlendColor.b = blue;
168 mLastBlendColor.a = alpha;
171 inline const Vector4& GetLastBlendColor() const
173 return mLastBlendColor;
176 inline void BlendEquation( GLenum mode ) override
178 mLastBlendEquationRgb = mode;
179 mLastBlendEquationAlpha = mode;
182 inline void BlendEquationSeparate( GLenum modeRgb, GLenum modeAlpha ) override
184 mLastBlendEquationRgb = modeRgb;
185 mLastBlendEquationAlpha = modeAlpha;
188 inline GLenum GetLastBlendEquationRgb() const
190 return mLastBlendEquationRgb;
193 inline GLenum GetLastBlendEquationAlpha() const
195 return mLastBlendEquationAlpha;
198 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
200 mLastBlendFuncSrcRgb = sfactor;
201 mLastBlendFuncDstRgb = dfactor;
202 mLastBlendFuncSrcAlpha = sfactor;
203 mLastBlendFuncDstAlpha = dfactor;
206 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
208 mLastBlendFuncSrcRgb = srcRGB;
209 mLastBlendFuncDstRgb = dstRGB;
210 mLastBlendFuncSrcAlpha = srcAlpha;
211 mLastBlendFuncDstAlpha = dstAlpha;
214 inline GLenum GetLastBlendFuncSrcRgb() const
216 return mLastBlendFuncSrcRgb;
219 inline GLenum GetLastBlendFuncDstRgb() const
221 return mLastBlendFuncDstRgb;
224 inline GLenum GetLastBlendFuncSrcAlpha() const
226 return mLastBlendFuncSrcAlpha;
229 inline GLenum GetLastBlendFuncDstAlpha() const
231 return mLastBlendFuncDstAlpha;
234 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
236 mBufferDataCalls.push_back(size);
239 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
241 mBufferSubDataCalls.push_back(size);
244 inline GLenum CheckFramebufferStatus(GLenum target) override
246 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
247 //Framebuffer texture have been called
248 if( mFramebufferStatus == 7 )
250 return GL_FRAMEBUFFER_COMPLETE;
253 return mCheckFramebufferStatusResult;
256 inline GLuint CheckFramebufferColorAttachmentCount()
258 return mFramebufferColorAttachmentCount;
261 inline GLenum CheckFramebufferDepthAttachment()
263 return mFramebufferDepthAttached;
266 inline GLenum CheckFramebufferStencilAttachment()
268 return mFramebufferStencilAttached;
271 inline void Clear(GLbitfield mask) override
274 mLastClearBitMask = mask;
277 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
279 mLastClearColor.r = red;
280 mLastClearColor.g = green;
281 mLastClearColor.b = blue;
282 mLastClearColor.a = alpha;
285 inline const Vector4& GetLastClearColor() const
287 return mLastClearColor;
290 inline void ClearDepthf(GLclampf depth) override
294 inline void ClearStencil(GLint s) override
296 std::stringstream out;
299 TraceCallStack::NamedParams namedParams;
300 namedParams["s"] = ToString( s );
302 mStencilFunctionTrace.PushCall( "ClearStencil", out.str(), namedParams );
305 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
307 mColorMaskParams.red = red;
308 mColorMaskParams.green = green;
309 mColorMaskParams.blue = blue;
310 mColorMaskParams.alpha = alpha;
313 inline void CompileShader(GLuint shader) override
315 std::stringstream out;
317 TraceCallStack::NamedParams namedParams;
318 namedParams["shader"] = ToString(shader);
320 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
323 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
325 std::stringstream out;
326 out << target<<", "<<level<<", "<<width << ", " << height;
328 TraceCallStack::NamedParams namedParams;
329 namedParams["target"] = ToString(target);
330 namedParams["level"] = ToString(level);
331 namedParams["internalformat"] = ToString(internalformat);
332 namedParams["width"] = ToString(width);
333 namedParams["height"] = ToString(height);
334 namedParams["border"] = ToString(border);
335 namedParams["size"] = ToString(imageSize);
337 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
340 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
342 std::stringstream out;
343 out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
345 TraceCallStack::NamedParams namedParams;
346 namedParams["target"] = ToString(target);
347 namedParams["level"] = ToString(level);
348 namedParams["xoffset"] = ToString(xoffset);
349 namedParams["yoffset"] = ToString(yoffset);
350 namedParams["width"] = ToString(width);
351 namedParams["height"] = ToString(height);
352 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
355 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
359 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
363 inline GLuint CreateProgram(void) override
365 mShaderTrace.PushCall("CreateProgram", "");
367 ++mLastProgramIdUsed;
368 mUniforms[mLastProgramIdUsed] = UniformIDMap();
369 return mLastProgramIdUsed;
372 inline GLuint CreateShader(GLenum type) override
374 std::stringstream out;
377 TraceCallStack::NamedParams namedParams;
378 namedParams["type"] = ToString(type);
379 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
381 return ++mLastShaderIdUsed;
384 inline void CullFace(GLenum mode) override
386 std::stringstream out;
389 TraceCallStack::NamedParams namedParams;
390 namedParams["program"] = ToString(mode);
392 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
395 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
399 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
403 inline void DeleteProgram(GLuint program) override
405 std::stringstream out;
408 TraceCallStack::NamedParams namedParams;
409 namedParams["program"] = ToString(program);
411 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
414 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
418 inline void DeleteShader(GLuint shader) override
420 std::stringstream out;
423 TraceCallStack::NamedParams namedParams;
424 namedParams["shader"] = ToString(shader);
426 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
429 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
431 std::stringstream out;
432 out << n << ", " << textures << " = [";
434 TraceCallStack::NamedParams namedParams;
436 for(GLsizei i=0; i<n; i++)
438 out << textures[i] << ", ";
439 std::stringstream paramName;
440 paramName<<"texture["<<i<<"]";
441 namedParams[paramName.str()] = ToString(textures[i]);
442 mDeletedTextureIds.push_back(textures[i]);
443 mNumGeneratedTextures--;
447 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
450 inline bool CheckNoTexturesDeleted()
452 return mDeletedTextureIds.size() == 0;
455 inline bool CheckTextureDeleted( GLuint textureId )
459 for(std::vector<GLuint>::iterator iter=mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
461 if(*iter == textureId)
470 inline void ClearDeletedTextures()
472 mDeletedTextureIds.clear();
475 inline void DepthFunc(GLenum func) override
477 std::stringstream out;
480 TraceCallStack::NamedParams namedParams;
481 namedParams["func"] = ToString(func);
483 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
486 inline void DepthMask(GLboolean flag) override
488 mLastDepthMask = flag;
491 inline bool GetLastDepthMask() const
493 return mLastDepthMask;
496 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
500 inline void DetachShader(GLuint program, GLuint shader) override
502 std::stringstream out;
503 out << program << ", " << shader;
504 TraceCallStack::NamedParams namedParams;
505 namedParams["program"] = ToString(program);
506 namedParams["shader"] = ToString(shader);
507 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
510 inline void Disable(GLenum cap) override
512 std::stringstream out;
514 TraceCallStack::NamedParams namedParams;
515 namedParams["cap"] = ToString(cap);
516 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
519 inline void DisableVertexAttribArray(GLuint index) override
521 SetVertexAttribArray( index, false );
524 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
526 std::stringstream out;
527 out << mode << ", " << first << ", " << count;
528 TraceCallStack::NamedParams namedParams;
529 namedParams["mode"] = ToString(mode);
530 namedParams["first"] = ToString(first);
531 namedParams["count"] = ToString(count);
532 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
535 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
537 std::stringstream out;
538 out << mode << ", " << count << ", " << type << ", indices";
540 TraceCallStack::NamedParams namedParams;
541 namedParams["mode"] = ToString(mode);
542 namedParams["count"] = ToString(count);
543 namedParams["type"] = ToString(type);
544 // Skip void pointers - are they of any use?
545 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
548 inline void Enable(GLenum cap) override
550 std::stringstream out;
552 TraceCallStack::NamedParams namedParams;
553 namedParams["cap"] = ToString(cap);
554 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
557 inline void EnableVertexAttribArray(GLuint index) override
559 SetVertexAttribArray( index, true);
562 inline void Finish(void) override
566 inline void Flush(void) override
570 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
572 if (attachment == GL_DEPTH_ATTACHMENT)
574 mFramebufferDepthAttached = true;
576 else if (attachment == GL_STENCIL_ATTACHMENT)
578 mFramebufferStencilAttached = true;
582 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
585 mFramebufferStatus |= 4;
587 //We check 4 attachment colors
588 if ((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
590 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
591 if ((mFrameBufferColorStatus & mask) == 0)
593 mFrameBufferColorStatus |= mask;
594 ++mFramebufferColorAttachmentCount;
599 inline void FrontFace(GLenum mode) override
603 inline void GenBuffers(GLsizei n, GLuint* buffers) override
605 // avoids an assert in GpuBuffers
609 inline void GenerateMipmap(GLenum target) override
611 std::stringstream out;
613 TraceCallStack::NamedParams namedParams;
614 namedParams["target"] = ToString(target);
616 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
619 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
621 for( int i = 0; i < n; i++ )
623 framebuffers[i] = i + 1;
626 //Add 001 bit, this function needs to be called the first one in the chain
627 mFramebufferStatus = 1;
630 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
632 for( int i = 0; i < n; i++ )
634 renderbuffers[i] = i + 1;
639 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
640 * @param[in] ids A vector containing the next IDs to be generated
642 inline void SetNextTextureIds( const std::vector<GLuint>& ids )
644 mNextTextureIds = ids;
647 inline const std::vector<GLuint>& GetNextTextureIds()
649 return mNextTextureIds;
652 inline void GenTextures(GLsizei count, GLuint* textures) override
654 for( int i=0; i<count; ++i )
656 if( !mNextTextureIds.empty() )
658 *(textures+i) = mNextTextureIds[0];
659 mNextTextureIds.erase( mNextTextureIds.begin() );
663 *(textures+i) = ++mLastAutoTextureIdUsed;
665 mNumGeneratedTextures++;
668 TraceCallStack::NamedParams namedParams;
669 namedParams["count"] = ToString(count);
671 std::stringstream out;
672 for(int i=0; i<count; i++)
679 std::ostringstream oss;
680 oss<<"indices["<<i<<"]";
681 namedParams[oss.str()] = ToString(textures[i]);
684 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
687 inline GLuint GetLastGenTextureId()
689 return mLastAutoTextureIdUsed;
692 inline GLuint GetNumGeneratedTextures()
694 return mNumGeneratedTextures;
697 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
701 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
706 *length = snprintf(name, bufsize, "sTexture");
707 *type = GL_SAMPLER_2D;
711 *length = snprintf(name, bufsize, "sEffect");
712 *type = GL_SAMPLER_2D;
716 *length = snprintf(name, bufsize, "sGloss");
717 *type = GL_SAMPLER_2D;
725 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
729 inline int GetAttribLocation(GLuint program, const char* name) override
731 std::string attribName(name);
733 for( unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i )
735 if( mStdAttribs[i] == attribName )
741 // 0 is a valid location
745 inline void GetBooleanv(GLenum pname, GLboolean* params) override
749 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
753 inline GLenum GetError(void) override
755 return mGetErrorResult;
758 inline void GetFloatv(GLenum pname, GLfloat* params) override
762 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
766 inline void GetIntegerv(GLenum pname, GLint* params) override
770 case GL_MAX_TEXTURE_SIZE:
773 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
776 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
777 *params = mNumBinaryFormats;
779 case GL_PROGRAM_BINARY_FORMATS_OES:
780 *params = mBinaryFormats;
785 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
790 *params = mLinkStatus;
792 case GL_PROGRAM_BINARY_LENGTH_OES:
793 *params = mProgramBinaryLength;
795 case GL_ACTIVE_UNIFORMS:
796 *params = mNumberOfActiveUniforms;
798 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
804 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
808 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
812 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,
1287 Vector3( x, y, z ) ) )
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
1894 inline void AddUniformCallToTraceStack( GLint location, std::string& value )
1896 std::string name = "<not found>";
1897 bool matched = false;
1899 UniformIDMap& map = mUniforms[mCurrentProgram];
1900 for (UniformIDMap::iterator it=map.begin(); it!=map.end(); ++it)
1902 if( it->second == location )
1912 mSetUniformTrace.PushCall( name, value );
1917 public: // TEST FUNCTIONS
1918 inline void SetCompileStatus( GLuint value ) { mCompileStatus = value; }
1919 inline void SetLinkStatus( GLuint value ) { mLinkStatus = value; }
1920 inline void SetGetAttribLocationResult( int result) { mGetAttribLocationResult = result; }
1921 inline void SetGetErrorResult( GLenum result) { mGetErrorResult = result; }
1922 inline void SetGetStringResult( GLubyte* result) { mGetStringResult = result; }
1923 inline void SetIsBufferResult( GLboolean result) { mIsBufferResult = result; }
1924 inline void SetIsEnabledResult( GLboolean result) { mIsEnabledResult = result; }
1925 inline void SetIsFramebufferResult( GLboolean result) { mIsFramebufferResult = result; }
1926 inline void SetIsProgramResult( GLboolean result) { mIsProgramResult = result; }
1927 inline void SetIsRenderbufferResult( GLboolean result) { mIsRenderbufferResult = result; }
1928 inline void SetIsShaderResult( GLboolean result) { mIsShaderResult = result; }
1929 inline void SetIsTextureResult( GLboolean result) { mIsTextureResult = result; }
1930 inline void SetCheckFramebufferStatusResult( GLenum result) { mCheckFramebufferStatusResult = result; }
1931 inline void SetNumBinaryFormats( GLint numFormats ) { mNumBinaryFormats = numFormats; }
1932 inline void SetBinaryFormats( GLint binaryFormats ) { mBinaryFormats = binaryFormats; }
1933 inline void SetProgramBinaryLength( GLint length ) { mProgramBinaryLength = length; }
1935 inline bool GetVertexAttribArrayState(GLuint index)
1937 if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
1942 return mVertexAttribArrayState[ index ];
1944 inline void ClearVertexAttribArrayChanged() { mVertexAttribArrayChanged = false; }
1945 inline bool GetVertexAttribArrayChanged() { return mVertexAttribArrayChanged; }
1947 //Methods for CullFace verification
1948 inline void EnableCullFaceCallTrace(bool enable) { mCullFaceTrace.Enable(enable); }
1949 inline void ResetCullFaceCallStack() { mCullFaceTrace.Reset(); }
1950 inline TraceCallStack& GetCullFaceTrace() { return mCullFaceTrace; }
1952 //Methods for Enable/Disable call verification
1953 inline void EnableEnableDisableCallTrace(bool enable) { mEnableDisableTrace.Enable(enable); }
1954 inline void ResetEnableDisableCallStack() { mEnableDisableTrace.Reset(); }
1955 inline TraceCallStack& GetEnableDisableTrace() { return mEnableDisableTrace; }
1957 //Methods for Shader verification
1958 inline void EnableShaderCallTrace(bool enable) { mShaderTrace.Enable(enable); }
1959 inline void ResetShaderCallStack() { mShaderTrace.Reset(); }
1960 inline TraceCallStack& GetShaderTrace() { return mShaderTrace; }
1962 //Methods for Texture verification
1963 inline void EnableTextureCallTrace(bool enable) { mTextureTrace.Enable(enable); }
1964 inline void ResetTextureCallStack() { mTextureTrace.Reset(); }
1965 inline TraceCallStack& GetTextureTrace() { return mTextureTrace; }
1967 //Methods for Texture verification
1968 inline void EnableTexParameterCallTrace(bool enable) { mTexParamaterTrace.Enable(enable); }
1969 inline void ResetTexParameterCallStack() { mTexParamaterTrace.Reset(); }
1970 inline TraceCallStack& GetTexParameterTrace() { return mTexParamaterTrace; }
1972 //Methods for Draw verification
1973 inline void EnableDrawCallTrace(bool enable) { mDrawTrace.Enable(enable); }
1974 inline void ResetDrawCallStack() { mDrawTrace.Reset(); }
1975 inline TraceCallStack& GetDrawTrace() { return mDrawTrace; }
1977 //Methods for Depth function verification
1978 inline void EnableDepthFunctionCallTrace(bool enable) { mDepthFunctionTrace.Enable(enable); }
1979 inline void ResetDepthFunctionCallStack() { mDepthFunctionTrace.Reset(); }
1980 inline TraceCallStack& GetDepthFunctionTrace() { return mDepthFunctionTrace; }
1982 //Methods for Stencil function verification
1983 inline void EnableStencilFunctionCallTrace(bool enable) { mStencilFunctionTrace.Enable(enable); }
1984 inline void ResetStencilFunctionCallStack() { mStencilFunctionTrace.Reset(); }
1985 inline TraceCallStack& GetStencilFunctionTrace() { return mStencilFunctionTrace; }
1987 //Methods for Scissor verification
1988 inline void EnableScissorCallTrace(bool enable) { mScissorTrace.Enable(enable); }
1989 inline void ResetScissorCallStack() { mScissorTrace.Reset(); }
1990 inline TraceCallStack& GetScissorTrace() { return mScissorTrace; }
1992 //Methods for Uniform function verification
1993 inline void EnableSetUniformCallTrace(bool enable) { mSetUniformTrace.Enable(enable); }
1994 inline void ResetSetUniformCallStack() { mSetUniformTrace.Reset(); }
1995 inline TraceCallStack& GetSetUniformTrace() { return mSetUniformTrace; }
1997 //Methods for Viewport verification
1998 inline void EnableViewportCallTrace(bool enable) { mViewportTrace.Enable(enable); }
1999 inline void ResetViewportCallStack() { mViewportTrace.Reset(); }
2000 inline TraceCallStack& GetViewportTrace() { return mViewportTrace; }
2002 template <typename T>
2003 inline bool GetUniformValue( const char* name, T& value ) const
2005 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2006 program_it != mUniforms.end();
2009 const UniformIDMap &uniformIDs = program_it->second;
2011 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2012 if( uniform_it != uniformIDs.end() )
2014 // found one matching uniform name, lets check the value...
2015 GLuint programId = program_it->first;
2016 GLint uniformId = uniform_it->second;
2018 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
2019 return mProgramUniforms.GetUniformValue( programId, uniformId, value );
2026 template <typename T>
2027 inline bool CheckUniformValue( const char* name, const T& value ) const
2029 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2030 program_it != mUniforms.end();
2033 const UniformIDMap &uniformIDs = program_it->second;
2035 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2036 if( uniform_it != uniformIDs.end() )
2038 // found one matching uniform name, lets check the value...
2039 GLuint programId = program_it->first;
2040 GLint uniformId = uniform_it->second;
2042 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
2043 if( mProgramUniforms.CheckUniformValue( programId, uniformId, value ) )
2045 // the value matches
2051 fprintf(stderr, "Not found, printing possible values:\n" );
2052 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2053 program_it != mUniforms.end();
2056 const UniformIDMap &uniformIDs = program_it->second;
2058 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2059 if( uniform_it != uniformIDs.end() )
2061 // found one matching uniform name, lets check the value...
2062 GLuint programId = program_it->first;
2063 GLint uniformId = uniform_it->second;
2065 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
2067 if ( mProgramUniforms.GetUniformValue(programId, uniformId, origValue) )
2069 std::stringstream out;
2070 out << uniform_it->first << ": " << origValue;
2071 fprintf(stderr, "%s\n", out.str().c_str() );
2078 template <typename T>
2079 inline bool GetUniformValue( GLuint programId, GLuint uniformId, T& outValue) const
2081 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( outValue );
2082 return mProgramUniforms.GetUniformValue( programId, uniformId, outValue );
2085 inline bool GetUniformIds( const char* name, GLuint& programId, GLuint& uniformId ) const
2087 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2088 program_it != mUniforms.end();
2091 const UniformIDMap &uniformIDs = program_it->second;
2093 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2094 if( uniform_it != uniformIDs.end() )
2096 programId = program_it->first;
2097 uniformId = uniform_it->second;
2104 inline GLuint GetLastShaderCompiled() const
2106 return mLastShaderCompiled;
2109 inline GLuint GetLastProgramCreated() const
2111 return mLastProgramIdUsed;
2114 inline GLbitfield GetLastClearMask() const
2116 return mLastClearBitMask;
2121 ATTRIB_UNKNOWN = -1,
2126 ATTRIB_BONE_WEIGHTS,
2127 ATTRIB_BONE_INDICES,
2131 struct ScissorParams
2138 ScissorParams() : x( 0 ), y( 0 ), width( 0 ), height( 0 ) { }
2141 // Methods to check scissor tests
2142 inline const ScissorParams& GetScissorParams() const { return mScissorParams; }
2144 struct ColorMaskParams
2151 ColorMaskParams() : red( true ), green( true ), blue( true ), alpha( true ) { }
2154 inline bool GetProgramBinaryCalled() const { return mGetProgramBinaryCalled; }
2156 inline unsigned int GetClearCountCalled() const { return mClearCount; }
2158 inline const ColorMaskParams& GetColorMaskParams() const { return mColorMaskParams; }
2160 typedef std::vector<size_t> BufferDataCalls;
2161 inline const BufferDataCalls& GetBufferDataCalls() const { return mBufferDataCalls; }
2162 inline void ResetBufferDataCalls() { mBufferDataCalls.clear(); }
2164 typedef std::vector<size_t> BufferSubDataCalls;
2165 inline const BufferSubDataCalls& GetBufferSubDataCalls() const { return mBufferSubDataCalls; }
2166 inline void ResetBufferSubDataCalls() { mBufferSubDataCalls.clear(); }
2169 GLuint mCurrentProgram;
2170 GLuint mCompileStatus;
2171 BufferDataCalls mBufferDataCalls;
2172 BufferSubDataCalls mBufferSubDataCalls;
2174 GLint mNumberOfActiveUniforms;
2175 GLint mGetAttribLocationResult;
2176 GLenum mGetErrorResult;
2177 GLubyte* mGetStringResult;
2178 GLboolean mIsBufferResult;
2179 GLboolean mIsEnabledResult;
2180 GLboolean mIsFramebufferResult;
2181 GLboolean mIsProgramResult;
2182 GLboolean mIsRenderbufferResult;
2183 GLboolean mIsShaderResult;
2184 GLboolean mIsTextureResult;
2185 GLenum mActiveTextureUnit;
2186 GLenum mCheckFramebufferStatusResult;
2187 GLint mFramebufferStatus;
2188 GLenum mFramebufferDepthAttached;
2189 GLenum mFramebufferStencilAttached;
2190 GLuint mFramebufferColorAttachmentCount;
2191 GLuint mFrameBufferColorStatus;
2192 GLint mNumBinaryFormats;
2193 GLint mBinaryFormats;
2194 GLint mProgramBinaryLength;
2195 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2196 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2197 bool mGetProgramBinaryCalled;
2198 typedef std::map< GLuint, std::string> ShaderSourceMap;
2199 ShaderSourceMap mShaderSources;
2200 GLuint mLastShaderCompiled;
2201 GLbitfield mLastClearBitMask;
2202 Vector4 mLastClearColor;
2203 unsigned int mClearCount;
2205 Vector4 mLastBlendColor;
2206 GLenum mLastBlendEquationRgb;
2207 GLenum mLastBlendEquationAlpha;
2208 GLenum mLastBlendFuncSrcRgb;
2209 GLenum mLastBlendFuncDstRgb;
2210 GLenum mLastBlendFuncSrcAlpha;
2211 GLenum mLastBlendFuncDstAlpha;
2213 GLboolean mLastDepthMask;
2215 // Data for manipulating the IDs returned by GenTextures
2216 GLuint mLastAutoTextureIdUsed;
2217 GLuint mNumGeneratedTextures;
2218 std::vector<GLuint> mNextTextureIds;
2219 std::vector<GLuint> mDeletedTextureIds;
2220 std::vector<GLuint> mBoundTextures;
2222 struct ActiveTextureType
2224 std::vector<GLuint> mBoundTextures;
2227 ActiveTextureType mActiveTextures[ MIN_TEXTURE_UNIT_LIMIT ];
2229 TraceCallStack mCullFaceTrace;
2230 TraceCallStack mEnableDisableTrace;
2231 TraceCallStack mShaderTrace;
2232 TraceCallStack mTextureTrace;
2233 TraceCallStack mTexParamaterTrace;
2234 TraceCallStack mDrawTrace;
2235 TraceCallStack mDepthFunctionTrace;
2236 TraceCallStack mStencilFunctionTrace;
2237 TraceCallStack mScissorTrace;
2238 TraceCallStack mSetUniformTrace;
2239 TraceCallStack mViewportTrace;
2241 // Shaders & Uniforms
2242 GLuint mLastShaderIdUsed;
2243 GLuint mLastProgramIdUsed;
2244 GLuint mLastUniformIdUsed;
2245 typedef std::map< std::string, GLint > UniformIDMap;
2246 typedef std::map< GLuint, UniformIDMap > ProgramUniformMap;
2247 ProgramUniformMap mUniforms;
2249 template <typename T>
2250 struct ProgramUniformValue : public std::map< GLuint, std::map< GLint, T > >
2253 typedef std::map< GLint, T > UniformValueMap;
2254 typedef std::map< GLuint, UniformValueMap > Map;
2256 bool SetUniformValue( GLuint program, GLuint uniform, const T& value )
2263 typename Map::iterator it = Map::find( program );
2264 if( it == Map::end() )
2266 // if its the first uniform for this program add it
2267 std::pair< typename Map::iterator, bool > result =
2268 Map::insert( typename Map::value_type( program, UniformValueMap() ) );
2272 UniformValueMap& uniforms = it->second;
2273 uniforms[uniform] = value;
2278 bool CheckUniformValue( GLuint program, GLuint uniform, const T& value ) const
2281 if ( GetUniformValue( program, uniform, uniformValue ) )
2283 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2289 bool GetUniformValue( GLuint program, GLuint uniform, T& value ) const
2296 typename Map::const_iterator it = Map::find( program );
2297 if( it == Map::end() )
2299 // Uniform values always initialised as 0
2304 const UniformValueMap& uniforms = it->second;
2305 typename UniformValueMap::const_iterator it2 = uniforms.find( uniform );
2306 if( it2 == uniforms.end() )
2308 // Uniform values always initialised as 0
2312 value = it2->second;
2319 ProgramUniformValue<int> mProgramUniforms1i;
2320 ProgramUniformValue<float> mProgramUniforms1f;
2321 ProgramUniformValue<Vector2> mProgramUniforms2f;
2322 ProgramUniformValue<Vector3> mProgramUniforms3f;
2323 ProgramUniformValue<Vector4> mProgramUniforms4f;
2324 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2325 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2327 inline const ProgramUniformValue<int>& GetProgramUniformsForType( const int ) const
2329 return mProgramUniforms1i;
2331 inline const ProgramUniformValue<float>& GetProgramUniformsForType( const float ) const
2333 return mProgramUniforms1f;
2335 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType( const Vector2& ) const
2337 return mProgramUniforms2f;
2339 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType( const Vector3& ) const
2341 return mProgramUniforms3f;
2343 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType( const Vector4& ) const
2345 return mProgramUniforms4f;
2347 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType( const Matrix& ) const
2349 return mProgramUniformsMat4;
2351 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType( const Matrix3& ) const
2353 return mProgramUniformsMat3;
2355 inline void SetVertexAttribArray(GLuint index, bool state)
2357 if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
2362 mVertexAttribArrayState[ index ] = state;
2363 mVertexAttribArrayChanged = true;
2366 ScissorParams mScissorParams;
2367 ColorMaskParams mColorMaskParams;
2371 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2377 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2383 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2385 return Vector2::ZERO;
2389 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2391 return Vector3::ZERO;
2395 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2397 return Vector4::ZERO;
2401 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2407 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2409 return Matrix3( Matrix() );
2414 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2415 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2418 #endif // TEST_GL_ABSTRACTION_H