1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2018 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/integration-api/core.h>
33 #include <dali/integration-api/gl-abstraction.h>
34 #include <dali/integration-api/gl-defines.h>
35 #include <test-trace-call-stack.h>
36 #include <test-compare-types.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
64 inline void ActiveTexture( GLenum textureUnit )
66 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
69 inline GLenum GetActiveTextureUnit() const
71 return mActiveTextureUnit + GL_TEXTURE0;
74 inline void AttachShader( GLuint program, GLuint shader )
76 std::stringstream out;
77 out << program << ", " << shader;
79 TraceCallStack::NamedParams namedParams;
80 namedParams["program"] = ToString(program);
81 namedParams["shader"] = ToString(shader);
82 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
85 inline void BindAttribLocation( GLuint program, GLuint index, const char* name )
89 inline void BindBuffer( GLenum target, GLuint buffer )
93 inline void BindFramebuffer( GLenum target, GLuint framebuffer )
96 mFramebufferStatus |= 2;
99 inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
104 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
105 * @return A vector containing the IDs that were bound.
107 inline const std::vector<GLuint>& GetBoundTextures() const
109 return mBoundTextures;
113 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
114 * @param[in] activeTextureUnit The specific active texture unit.
115 * @return A vector containing the IDs that were bound.
117 inline const std::vector<GLuint>& GetBoundTextures( GLuint activeTextureUnit ) const
119 return mActiveTextures[ activeTextureUnit - GL_TEXTURE0 ].mBoundTextures;
123 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
125 inline void ClearBoundTextures()
127 mBoundTextures.clear();
129 for( unsigned int i=0; i<MIN_TEXTURE_UNIT_LIMIT; ++i )
131 mActiveTextures[ i ].mBoundTextures.clear();
135 inline void BindTexture( GLenum target, GLuint texture )
137 // Record the bound textures for future checks
140 mBoundTextures.push_back( texture );
142 if( mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT )
144 mActiveTextures[ mActiveTextureUnit ].mBoundTextures.push_back( texture );
148 std::stringstream out;
149 out << target << ", " << texture;
151 TraceCallStack::NamedParams namedParams;
152 namedParams["target"] = ToString(target);
153 namedParams["texture"] = ToString(texture);
155 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
158 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
160 mLastBlendColor.r = red;
161 mLastBlendColor.g = green;
162 mLastBlendColor.b = blue;
163 mLastBlendColor.a = alpha;
166 inline const Vector4& GetLastBlendColor() const
168 return mLastBlendColor;
171 inline void BlendEquation( GLenum mode )
173 mLastBlendEquationRgb = mode;
174 mLastBlendEquationAlpha = mode;
177 inline void BlendEquationSeparate( GLenum modeRgb, GLenum modeAlpha )
179 mLastBlendEquationRgb = modeRgb;
180 mLastBlendEquationAlpha = modeAlpha;
183 inline GLenum GetLastBlendEquationRgb() const
185 return mLastBlendEquationRgb;
188 inline GLenum GetLastBlendEquationAlpha() const
190 return mLastBlendEquationAlpha;
193 inline void BlendFunc(GLenum sfactor, GLenum dfactor)
195 mLastBlendFuncSrcRgb = sfactor;
196 mLastBlendFuncDstRgb = dfactor;
197 mLastBlendFuncSrcAlpha = sfactor;
198 mLastBlendFuncDstAlpha = dfactor;
201 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
203 mLastBlendFuncSrcRgb = srcRGB;
204 mLastBlendFuncDstRgb = dstRGB;
205 mLastBlendFuncSrcAlpha = srcAlpha;
206 mLastBlendFuncDstAlpha = dstAlpha;
209 inline GLenum GetLastBlendFuncSrcRgb() const
211 return mLastBlendFuncSrcRgb;
214 inline GLenum GetLastBlendFuncDstRgb() const
216 return mLastBlendFuncDstRgb;
219 inline GLenum GetLastBlendFuncSrcAlpha() const
221 return mLastBlendFuncSrcAlpha;
224 inline GLenum GetLastBlendFuncDstAlpha() const
226 return mLastBlendFuncDstAlpha;
229 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
231 mBufferDataCalls.push_back(size);
234 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
236 mBufferSubDataCalls.push_back(size);
239 inline GLenum CheckFramebufferStatus(GLenum target)
241 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
242 //Framebuffer texture have been called
243 if( mFramebufferStatus == 7 )
245 return GL_FRAMEBUFFER_COMPLETE;
248 return mCheckFramebufferStatusResult;
251 inline GLenum CheckFramebufferColorAttachment()
253 return mFramebufferColorAttached;
256 inline GLenum CheckFramebufferDepthAttachment()
258 return mFramebufferDepthAttached;
261 inline GLenum CheckFramebufferStencilAttachment()
263 return mFramebufferStencilAttached;
266 inline void Clear(GLbitfield mask)
269 mLastClearBitMask = mask;
272 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
276 inline void ClearDepthf(GLclampf depth)
280 inline void ClearStencil(GLint s)
282 std::stringstream out;
285 TraceCallStack::NamedParams namedParams;
286 namedParams["s"] = ToString( s );
288 mStencilFunctionTrace.PushCall( "ClearStencil", out.str(), namedParams );
291 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
293 mColorMaskParams.red = red;
294 mColorMaskParams.green = green;
295 mColorMaskParams.blue = blue;
296 mColorMaskParams.alpha = alpha;
299 inline void CompileShader(GLuint shader)
301 std::stringstream out;
303 TraceCallStack::NamedParams namedParams;
304 namedParams["shader"] = ToString(shader);
306 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
309 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
311 std::stringstream out;
312 out << target<<", "<<level<<", "<<width << ", " << height;
314 TraceCallStack::NamedParams namedParams;
315 namedParams["target"] = ToString(target);
316 namedParams["level"] = ToString(level);
317 namedParams["internalformat"] = ToString(internalformat);
318 namedParams["width"] = ToString(width);
319 namedParams["height"] = ToString(height);
320 namedParams["border"] = ToString(border);
321 namedParams["size"] = ToString(imageSize);
323 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
326 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
328 std::stringstream out;
329 out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
331 TraceCallStack::NamedParams namedParams;
332 namedParams["target"] = ToString(target);
333 namedParams["level"] = ToString(level);
334 namedParams["xoffset"] = ToString(xoffset);
335 namedParams["yoffset"] = ToString(yoffset);
336 namedParams["width"] = ToString(width);
337 namedParams["height"] = ToString(height);
338 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
341 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
345 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
349 inline GLuint CreateProgram(void)
351 mShaderTrace.PushCall("CreateProgram", "");
353 ++mLastProgramIdUsed;
354 mUniforms[mLastProgramIdUsed] = UniformIDMap();
355 return mLastProgramIdUsed;
358 inline GLuint CreateShader(GLenum type)
360 std::stringstream out;
363 TraceCallStack::NamedParams namedParams;
364 namedParams["type"] = ToString(type);
365 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
367 return ++mLastShaderIdUsed;
370 inline void CullFace(GLenum mode)
372 std::stringstream out;
375 TraceCallStack::NamedParams namedParams;
376 namedParams["program"] = ToString(mode);
378 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
381 inline void DeleteBuffers(GLsizei n, const GLuint* buffers)
385 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
389 inline void DeleteProgram(GLuint program)
391 std::stringstream out;
394 TraceCallStack::NamedParams namedParams;
395 namedParams["program"] = ToString(program);
397 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
400 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
404 inline void DeleteShader(GLuint shader)
406 std::stringstream out;
409 TraceCallStack::NamedParams namedParams;
410 namedParams["shader"] = ToString(shader);
412 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
415 inline void DeleteTextures(GLsizei n, const GLuint* textures)
417 std::stringstream out;
418 out << n << ", " << textures << " = [";
420 TraceCallStack::NamedParams namedParams;
422 for(GLsizei i=0; i<n; i++)
424 out << textures[i] << ", ";
425 std::stringstream paramName;
426 paramName<<"texture["<<i<<"]";
427 namedParams[paramName.str()] = ToString(textures[i]);
428 mDeletedTextureIds.push_back(textures[i]);
429 mNumGeneratedTextures--;
433 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
436 inline bool CheckNoTexturesDeleted()
438 return mDeletedTextureIds.size() == 0;
441 inline bool CheckTextureDeleted( GLuint textureId )
445 for(std::vector<GLuint>::iterator iter=mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
447 if(*iter == textureId)
456 inline void ClearDeletedTextures()
458 mDeletedTextureIds.clear();
461 inline void DepthFunc(GLenum func)
463 std::stringstream out;
466 TraceCallStack::NamedParams namedParams;
467 namedParams["func"] = ToString(func);
469 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
472 inline void DepthMask(GLboolean flag)
474 mLastDepthMask = flag;
477 inline bool GetLastDepthMask() const
479 return mLastDepthMask;
482 inline void DepthRangef(GLclampf zNear, GLclampf zFar)
486 inline void DetachShader(GLuint program, GLuint shader)
488 std::stringstream out;
489 out << program << ", " << shader;
490 TraceCallStack::NamedParams namedParams;
491 namedParams["program"] = ToString(program);
492 namedParams["shader"] = ToString(shader);
493 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
496 inline void Disable(GLenum cap)
498 std::stringstream out;
500 TraceCallStack::NamedParams namedParams;
501 namedParams["cap"] = ToString(cap);
502 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
505 inline void DisableVertexAttribArray(GLuint index)
507 SetVertexAttribArray( index, false );
510 inline void DrawArrays(GLenum mode, GLint first, GLsizei count)
512 std::stringstream out;
513 out << mode << ", " << first << ", " << count;
514 TraceCallStack::NamedParams namedParams;
515 namedParams["mode"] = ToString(mode);
516 namedParams["first"] = ToString(first);
517 namedParams["count"] = ToString(count);
518 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
521 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
523 std::stringstream out;
524 out << mode << ", " << count << ", " << type << ", indices";
526 TraceCallStack::NamedParams namedParams;
527 namedParams["mode"] = ToString(mode);
528 namedParams["count"] = ToString(count);
529 namedParams["type"] = ToString(type);
530 // Skip void pointers - are they of any use?
531 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
534 inline void Enable(GLenum cap)
536 std::stringstream out;
538 TraceCallStack::NamedParams namedParams;
539 namedParams["cap"] = ToString(cap);
540 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
543 inline void EnableVertexAttribArray(GLuint index)
545 SetVertexAttribArray( index, true);
548 inline void Finish(void)
552 inline void Flush(void)
556 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
558 if (attachment == GL_DEPTH_ATTACHMENT)
560 mFramebufferDepthAttached = true;
562 else if (attachment == GL_STENCIL_ATTACHMENT)
564 mFramebufferStencilAttached = true;
568 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
571 mFramebufferStatus |= 4;
573 //We check 4 attachment colors
574 if ((attachment == GL_COLOR_ATTACHMENT0) || (attachment == GL_COLOR_ATTACHMENT1) || (attachment == GL_COLOR_ATTACHMENT2) || (attachment == GL_COLOR_ATTACHMENT4))
576 mFramebufferColorAttached = true;
580 inline void FrontFace(GLenum mode)
584 inline void GenBuffers(GLsizei n, GLuint* buffers)
586 // avoids an assert in GpuBuffers
590 inline void GenerateMipmap(GLenum target)
592 std::stringstream out;
594 TraceCallStack::NamedParams namedParams;
595 namedParams["target"] = ToString(target);
597 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
600 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers)
602 for( int i = 0; i < n; i++ )
604 framebuffers[i] = i + 1;
607 //Add 001 bit, this function needs to be called the first one in the chain
608 mFramebufferStatus = 1;
611 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
613 for( int i = 0; i < n; i++ )
615 renderbuffers[i] = i + 1;
620 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
621 * @param[in] ids A vector containing the next IDs to be generated
623 inline void SetNextTextureIds( const std::vector<GLuint>& ids )
625 mNextTextureIds = ids;
628 inline const std::vector<GLuint>& GetNextTextureIds()
630 return mNextTextureIds;
633 inline void GenTextures(GLsizei count, GLuint* textures)
635 for( int i=0; i<count; ++i )
637 if( !mNextTextureIds.empty() )
639 *(textures+i) = mNextTextureIds[0];
640 mNextTextureIds.erase( mNextTextureIds.begin() );
644 *(textures+i) = ++mLastAutoTextureIdUsed;
646 mNumGeneratedTextures++;
649 TraceCallStack::NamedParams namedParams;
650 namedParams["count"] = ToString(count);
652 std::stringstream out;
653 for(int i=0; i<count; i++)
660 std::ostringstream oss;
661 oss<<"indices["<<i<<"]";
662 namedParams[oss.str()] = ToString(textures[i]);
665 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
668 inline GLuint GetLastGenTextureId()
670 return mLastAutoTextureIdUsed;
672 inline GLuint GetNumGeneratedTextures()
674 return mNumGeneratedTextures;
677 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
681 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
686 *length = snprintf(name, bufsize, "sTexture");
687 *type = GL_SAMPLER_2D;
691 *length = snprintf(name, bufsize, "sEffect");
692 *type = GL_SAMPLER_2D;
696 *length = snprintf(name, bufsize, "sGloss");
697 *type = GL_SAMPLER_2D;
705 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
709 inline int GetAttribLocation(GLuint program, const char* name)
711 std::string attribName(name);
713 for( unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i )
715 if( mStdAttribs[i] == attribName )
721 // 0 is a valid location
725 inline void GetBooleanv(GLenum pname, GLboolean* params)
729 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
733 inline GLenum GetError(void)
735 return mGetErrorResult;
738 inline void GetFloatv(GLenum pname, GLfloat* params)
742 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
746 inline void GetIntegerv(GLenum pname, GLint* params)
750 case GL_MAX_TEXTURE_SIZE:
753 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
756 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
757 *params = mNumBinaryFormats;
759 case GL_PROGRAM_BINARY_FORMATS_OES:
760 *params = mBinaryFormats;
765 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params)
770 *params = mLinkStatus;
772 case GL_PROGRAM_BINARY_LENGTH_OES:
773 *params = mProgramBinaryLength;
775 case GL_ACTIVE_UNIFORMS:
776 *params = mNumberOfActiveUniforms;
778 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
784 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
788 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
792 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params)
795 case GL_COMPILE_STATUS:
796 *params = mCompileStatus;
801 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
805 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
809 inline const GLubyte* GetString(GLenum name)
811 return mGetStringResult;
814 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
818 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
822 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params)
826 inline void GetUniformiv(GLuint program, GLint location, GLint* params)
830 inline GLint GetUniformLocation(GLuint program, const char* name)
832 ProgramUniformMap::iterator it = mUniforms.find(program);
833 if( it == mUniforms.end() )
835 // Not a valid program ID
836 mGetErrorResult = GL_INVALID_OPERATION;
840 UniformIDMap& uniformIDs = it->second;
841 UniformIDMap::iterator it2 = uniformIDs.find( name );
842 if( it2 == uniformIDs.end() )
844 // Uniform not found, so add it...
845 uniformIDs[name] = ++mLastUniformIdUsed;
846 return mLastUniformIdUsed;
852 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
856 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
860 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
864 inline void Hint(GLenum target, GLenum mode)
868 inline GLboolean IsBuffer(GLuint buffer)
870 return mIsBufferResult;
873 inline GLboolean IsEnabled(GLenum cap)
875 return mIsEnabledResult;
878 inline GLboolean IsFramebuffer(GLuint framebuffer)
880 return mIsFramebufferResult;
883 inline GLboolean IsProgram(GLuint program)
885 return mIsProgramResult;
888 inline GLboolean IsRenderbuffer(GLuint renderbuffer)
890 return mIsRenderbufferResult;
893 inline GLboolean IsShader(GLuint shader)
895 return mIsShaderResult;
898 inline GLboolean IsTexture(GLuint texture)
900 return mIsTextureResult;
903 inline void LineWidth(GLfloat width)
907 inline void LinkProgram(GLuint program)
909 std::stringstream out;
912 TraceCallStack::NamedParams namedParams;
913 namedParams["program"] = ToString(program);
914 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
916 mNumberOfActiveUniforms=3;
917 GetUniformLocation(program, "sTexture");
918 GetUniformLocation(program, "sEffect");
919 GetUniformLocation(program, "sGloss");
922 inline void PixelStorei(GLenum pname, GLint param)
926 inline void PolygonOffset(GLfloat factor, GLfloat units)
930 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
934 inline void ReleaseShaderCompiler(void)
938 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
942 inline void SampleCoverage(GLclampf value, GLboolean invert)
946 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
948 mScissorParams.x = x;
949 mScissorParams.y = y;
950 mScissorParams.width = width;
951 mScissorParams.height = height;
953 std::stringstream out;
954 out << x << ", " << y << ", " << width << ", " << height;
955 TraceCallStack::NamedParams namedParams;
956 namedParams["x"] = ToString( x );
957 namedParams["y"] = ToString( y );
958 namedParams["width"] = ToString( width );
959 namedParams["height"] = ToString( height );
960 mScissorTrace.PushCall( "Scissor", out.str(), namedParams );
963 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
967 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
969 std::string stringBuilder;
970 for(int i = 0; i < count; ++i)
972 stringBuilder += string[i];
974 mShaderSources[shader] = stringBuilder;
975 mLastShaderCompiled = shader;
978 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
980 const std::string shaderSource = mShaderSources[shader];
981 const int shaderSourceLength = static_cast<int>(shaderSource.length());
982 if( shaderSourceLength < bufsize )
984 strncpy( source, shaderSource.c_str(), shaderSourceLength );
985 *length = shaderSourceLength;
989 *length = bufsize -1;
990 strncpy(source, shaderSource.c_str(), *length);
991 source[*length] = 0x0;
995 inline std::string GetShaderSource(GLuint shader)
997 return mShaderSources[shader];
1000 inline void StencilFunc(GLenum func, GLint ref, GLuint mask)
1002 std::stringstream out;
1003 out << func << ", " << ref << ", " << mask;
1005 TraceCallStack::NamedParams namedParams;
1006 namedParams["func"] = ToString( func );
1007 namedParams["ref"] = ToString( ref );
1008 namedParams["mask"] = ToString( mask );
1010 mStencilFunctionTrace.PushCall( "StencilFunc", out.str(), namedParams );
1013 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1015 std::stringstream out;
1016 out << face << ", " << func << ", " << ref << ", " << mask;
1018 TraceCallStack::NamedParams namedParams;
1019 namedParams["face"] = ToString( face );
1020 namedParams["func"] = ToString( func );
1021 namedParams["ref"] = ToString( ref );
1022 namedParams["mask"] = ToString( mask );
1024 mStencilFunctionTrace.PushCall( "StencilFuncSeparate", out.str(), namedParams );
1027 inline void StencilMask(GLuint mask)
1029 std::stringstream out;
1032 TraceCallStack::NamedParams namedParams;
1033 namedParams["mask"] = ToString( mask );
1035 mStencilFunctionTrace.PushCall( "StencilMask", out.str(), namedParams );
1038 inline void StencilMaskSeparate(GLenum face, GLuint mask)
1040 std::stringstream out;
1041 out << face << ", " << mask;
1043 TraceCallStack::NamedParams namedParams;
1044 namedParams["face"] = ToString( face );
1045 namedParams["mask"] = ToString( mask );
1047 mStencilFunctionTrace.PushCall( "StencilMaskSeparate", out.str(), namedParams );
1050 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1052 std::stringstream out;
1053 out << fail << ", " << zfail << ", " << zpass;
1055 TraceCallStack::NamedParams namedParams;
1056 namedParams["fail"] = ToString( fail );
1057 namedParams["zfail"] = ToString( zfail );
1058 namedParams["zpass"] = ToString( zpass );
1060 mStencilFunctionTrace.PushCall( "StencilOp", out.str(), namedParams );
1063 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1065 std::stringstream out;
1066 out << face << ", " << fail << ", " << zfail << "," << zpass;
1068 TraceCallStack::NamedParams namedParams;
1069 namedParams["face"] = ToString( face );
1070 namedParams["fail"] = ToString( fail );
1071 namedParams["zfail"] = ToString( zfail );
1072 namedParams["zpass"] = ToString( zpass );
1074 mStencilFunctionTrace.PushCall( "StencilOpSeparate", out.str(), namedParams );
1077 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
1079 std::stringstream out;
1080 out << target<<", "<<level<<", "<<width << ", " << height;
1082 TraceCallStack::NamedParams namedParams;
1083 namedParams["target"] = ToString(target);
1084 namedParams["level"] = ToString(level);
1085 namedParams["internalformat"] = ToString(internalformat);
1086 namedParams["width"] = ToString(width);
1087 namedParams["height"] = ToString(height);
1088 namedParams["border"] = ToString(border);
1089 namedParams["format"] = ToString(format);
1090 namedParams["type"] = ToString(type);
1092 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1095 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param)
1097 std::stringstream out;
1098 out << target << ", " << pname << ", " << param;
1100 TraceCallStack::NamedParams namedParams;
1101 namedParams["target"] = ToString(target);
1102 namedParams["pname"] = ToString(pname);
1103 namedParams["param"] = ToString(param);
1105 mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
1108 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1110 std::stringstream out;
1111 out << target << ", " << pname << ", " << params[0];
1113 TraceCallStack::NamedParams namedParams;
1114 namedParams["target"] = ToString(target);
1115 namedParams["pname"] = ToString(pname);
1116 namedParams["params[0]"] = ToString(params[0]);
1118 mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1121 inline void TexParameteri(GLenum target, GLenum pname, GLint param)
1123 std::stringstream out;
1124 out << target << ", " << pname << ", " << param;
1125 TraceCallStack::NamedParams namedParams;
1126 namedParams["target"] = ToString(target);
1127 namedParams["pname"] = ToString(pname);
1128 namedParams["param"] = ToString(param);
1129 mTexParamaterTrace.PushCall("TexParameteri", out.str(), namedParams);
1132 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
1134 std::stringstream out;
1135 out << target << ", " << pname << ", " << params[0];
1136 TraceCallStack::NamedParams namedParams;
1137 namedParams["target"] = ToString(target);
1138 namedParams["pname"] = ToString(pname);
1139 namedParams["params[0]"] = ToString(params[0]);
1140 mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1143 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
1145 std::stringstream out;
1146 out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1148 TraceCallStack::NamedParams namedParams;
1149 namedParams["target"] = ToString(target);
1150 namedParams["level"] = ToString(level);
1151 namedParams["xoffset"] = ToString(xoffset);
1152 namedParams["yoffset"] = ToString(yoffset);
1153 namedParams["width"] = ToString(width);
1154 namedParams["height"] = ToString(height);
1155 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1158 inline void Uniform1f(GLint location, GLfloat value )
1160 std::string params = ToString( value );
1161 AddUniformCallToTraceStack( location, params );
1163 if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, value ) )
1165 mGetErrorResult = GL_INVALID_OPERATION;
1169 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v)
1172 for( int i = 0; i < count; ++i )
1174 params = params + ToString( v[i] ) + ",";
1177 AddUniformCallToTraceStack( location, params );
1179 for( int i = 0; i < count; ++i )
1181 if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, v[i] ) )
1183 mGetErrorResult = GL_INVALID_OPERATION;
1189 inline void Uniform1i(GLint location, GLint x)
1191 std::string params = ToString( x );
1193 AddUniformCallToTraceStack( location, params );
1195 if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram, location, x ) )
1197 mGetErrorResult = GL_INVALID_OPERATION;
1201 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v)
1203 std::string params = ToString( v );
1204 AddUniformCallToTraceStack( location, params );
1206 for( int i = 0; i < count; ++i )
1208 if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram,
1212 mGetErrorResult = GL_INVALID_OPERATION;
1218 inline void Uniform2f(GLint location, GLfloat x, GLfloat y)
1220 std::string params = ToString( x ) + "," + ToString( y );
1221 AddUniformCallToTraceStack( location, params );
1223 if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
1227 mGetErrorResult = GL_INVALID_OPERATION;
1231 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v)
1233 std::string params = ToString( v );
1234 AddUniformCallToTraceStack( location, params );
1236 for( int i = 0; i < count; ++i )
1238 if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
1240 Vector2( v[2*i], v[2*i+1] ) ) )
1242 mGetErrorResult = GL_INVALID_OPERATION;
1248 inline void Uniform2i(GLint location, GLint x, GLint y)
1250 std::string params = ToString( x ) + "," + ToString( y );
1251 AddUniformCallToTraceStack( location, params );
1254 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v)
1256 std::string params = ToString( v );
1257 AddUniformCallToTraceStack( location, params );
1260 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
1262 std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z );
1263 AddUniformCallToTraceStack( location, params );
1265 if( ! mProgramUniforms3f.SetUniformValue( mCurrentProgram,
1267 Vector3( x, y, z ) ) )
1269 mGetErrorResult = GL_INVALID_OPERATION;
1273 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v)
1275 std::string params = ToString( v );
1276 AddUniformCallToTraceStack( location, params );
1278 for( int i = 0; i < count; ++i )
1280 if( ! mProgramUniforms3f.SetUniformValue(
1283 Vector3( v[3*i], v[3*i+1], v[3*i+2] ) ) )
1285 mGetErrorResult = GL_INVALID_OPERATION;
1291 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z)
1293 std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z );
1294 AddUniformCallToTraceStack( location, params );
1297 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v)
1299 std::string params = ToString( v );
1300 AddUniformCallToTraceStack( location, params );
1303 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1305 std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z ) + "," + ToString( w );
1306 AddUniformCallToTraceStack( location, params );
1308 if( ! mProgramUniforms4f.SetUniformValue( mCurrentProgram,
1310 Vector4( x, y, z, w ) ) )
1312 mGetErrorResult = GL_INVALID_OPERATION;
1316 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v)
1318 std::string params = ToString( v );
1319 AddUniformCallToTraceStack( location, params );
1321 for( int i = 0; i < count; ++i )
1323 if( ! mProgramUniforms4f.SetUniformValue(
1326 Vector4( v[4*i], v[4*i+1], v[4*i+2], v[4*i+3] ) ) )
1328 mGetErrorResult = GL_INVALID_OPERATION;
1334 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
1336 std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z ) + "," + ToString( w );
1337 AddUniformCallToTraceStack( location, params );
1340 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v)
1342 std::string params = ToString( v );
1343 AddUniformCallToTraceStack( location, params );
1346 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1348 std::string params = ToString( value );
1349 AddUniformCallToTraceStack( location, params );
1352 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1354 std::string params = ToString( value );
1355 AddUniformCallToTraceStack( location, params );
1357 for( int i = 0; i < count; ++i )
1359 if( ! mProgramUniformsMat3.SetUniformValue(
1362 Matrix3( value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8] ) ) )
1364 mGetErrorResult = GL_INVALID_OPERATION;
1370 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1372 std::string params = ToString( value );
1373 AddUniformCallToTraceStack( location, params );
1375 for( int i = 0; i < count; ++i )
1377 if( ! mProgramUniformsMat4.SetUniformValue(
1382 mGetErrorResult = GL_INVALID_OPERATION;
1388 inline void UseProgram(GLuint program)
1390 mCurrentProgram = program;
1393 inline void ValidateProgram(GLuint program)
1397 inline void VertexAttrib1f(GLuint indx, GLfloat x)
1401 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values)
1405 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1409 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values)
1413 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1417 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values)
1421 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1425 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values)
1429 inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
1433 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
1439 inline void ReadBuffer(GLenum mode)
1443 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
1447 inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
1451 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)
1455 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1459 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
1463 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)
1467 inline void GenQueries(GLsizei n, GLuint* ids)
1471 inline void DeleteQueries(GLsizei n, const GLuint* ids)
1475 inline GLboolean IsQuery(GLuint id)
1480 inline void BeginQuery(GLenum target, GLuint id)
1484 inline void EndQuery(GLenum target)
1488 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1492 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1496 inline GLboolean UnmapBuffer(GLenum target)
1501 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1505 inline void DrawBuffers(GLsizei n, const GLenum* bufs)
1509 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1513 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1517 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1521 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1525 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1529 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1533 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
1537 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1541 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1545 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
1550 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
1554 inline void BindVertexArray(GLuint array)
1558 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays)
1562 inline void GenVertexArrays(GLsizei n, GLuint* arrays)
1566 inline GLboolean IsVertexArray(GLuint array)
1571 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data)
1575 inline void BeginTransformFeedback(GLenum primitiveMode)
1579 inline void EndTransformFeedback(void)
1583 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
1587 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer)
1591 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
1595 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
1599 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1603 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
1607 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
1611 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1615 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1619 inline void VertexAttribI4iv(GLuint index, const GLint* v)
1623 inline void VertexAttribI4uiv(GLuint index, const GLuint* v)
1627 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params)
1631 inline GLint GetFragDataLocation(GLuint program, const GLchar *name)
1636 inline void Uniform1ui(GLint location, GLuint v0)
1640 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1)
1644 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1648 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1652 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value)
1656 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value)
1660 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value)
1664 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value)
1668 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
1672 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
1676 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
1680 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1684 inline const GLubyte* GetStringi(GLenum name, GLuint index)
1689 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1693 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
1697 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
1701 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
1703 return GL_INVALID_INDEX;
1706 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
1710 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
1714 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1718 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
1722 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
1726 inline GLsync FenceSync(GLenum condition, GLbitfield flags)
1731 inline GLboolean IsSync(GLsync sync)
1736 inline void DeleteSync(GLsync sync)
1740 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1745 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1749 inline void GetInteger64v(GLenum pname, GLint64* params)
1753 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
1757 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
1761 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
1765 inline void GenSamplers(GLsizei count, GLuint* samplers)
1769 inline void DeleteSamplers(GLsizei count, const GLuint* samplers)
1773 inline GLboolean IsSampler(GLuint sampler)
1778 inline void BindSampler(GLuint unit, GLuint sampler)
1782 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1786 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
1790 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1794 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
1798 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
1802 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
1806 inline void VertexAttribDivisor(GLuint index, GLuint divisor)
1810 inline void BindTransformFeedback(GLenum target, GLuint id)
1814 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
1818 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids)
1822 inline GLboolean IsTransformFeedback(GLuint id)
1827 inline void PauseTransformFeedback(void)
1831 inline void ResumeTransformFeedback(void)
1835 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
1837 mGetProgramBinaryCalled = true;
1840 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
1844 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value)
1848 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
1852 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1856 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1860 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
1864 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
1870 inline void AddUniformCallToTraceStack( GLint location, std::string& value )
1872 std::string name = "<not found>";
1873 bool matched = false;
1875 UniformIDMap& map = mUniforms[mCurrentProgram];
1876 for (UniformIDMap::iterator it=map.begin(); it!=map.end(); ++it)
1878 if( it->second == location )
1888 mSetUniformTrace.PushCall( name, value );
1893 public: // TEST FUNCTIONS
1894 inline void SetCompileStatus( GLuint value ) { mCompileStatus = value; }
1895 inline void SetLinkStatus( GLuint value ) { mLinkStatus = value; }
1896 inline void SetGetAttribLocationResult( int result) { mGetAttribLocationResult = result; }
1897 inline void SetGetErrorResult( GLenum result) { mGetErrorResult = result; }
1898 inline void SetGetStringResult( GLubyte* result) { mGetStringResult = result; }
1899 inline void SetIsBufferResult( GLboolean result) { mIsBufferResult = result; }
1900 inline void SetIsEnabledResult( GLboolean result) { mIsEnabledResult = result; }
1901 inline void SetIsFramebufferResult( GLboolean result) { mIsFramebufferResult = result; }
1902 inline void SetIsProgramResult( GLboolean result) { mIsProgramResult = result; }
1903 inline void SetIsRenderbufferResult( GLboolean result) { mIsRenderbufferResult = result; }
1904 inline void SetIsShaderResult( GLboolean result) { mIsShaderResult = result; }
1905 inline void SetIsTextureResult( GLboolean result) { mIsTextureResult = result; }
1906 inline void SetCheckFramebufferStatusResult( GLenum result) { mCheckFramebufferStatusResult = result; }
1907 inline void SetNumBinaryFormats( GLint numFormats ) { mNumBinaryFormats = numFormats; }
1908 inline void SetBinaryFormats( GLint binaryFormats ) { mBinaryFormats = binaryFormats; }
1909 inline void SetProgramBinaryLength( GLint length ) { mProgramBinaryLength = length; }
1911 inline bool GetVertexAttribArrayState(GLuint index)
1913 if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
1918 return mVertexAttribArrayState[ index ];
1920 inline void ClearVertexAttribArrayChanged() { mVertexAttribArrayChanged = false; }
1921 inline bool GetVertexAttribArrayChanged() { return mVertexAttribArrayChanged; }
1923 //Methods for CullFace verification
1924 inline void EnableCullFaceCallTrace(bool enable) { mCullFaceTrace.Enable(enable); }
1925 inline void ResetCullFaceCallStack() { mCullFaceTrace.Reset(); }
1926 inline TraceCallStack& GetCullFaceTrace() { return mCullFaceTrace; }
1928 //Methods for Enable/Disable call verification
1929 inline void EnableEnableDisableCallTrace(bool enable) { mEnableDisableTrace.Enable(enable); }
1930 inline void ResetEnableDisableCallStack() { mEnableDisableTrace.Reset(); }
1931 inline TraceCallStack& GetEnableDisableTrace() { return mEnableDisableTrace; }
1933 //Methods for Shader verification
1934 inline void EnableShaderCallTrace(bool enable) { mShaderTrace.Enable(enable); }
1935 inline void ResetShaderCallStack() { mShaderTrace.Reset(); }
1936 inline TraceCallStack& GetShaderTrace() { return mShaderTrace; }
1938 //Methods for Texture verification
1939 inline void EnableTextureCallTrace(bool enable) { mTextureTrace.Enable(enable); }
1940 inline void ResetTextureCallStack() { mTextureTrace.Reset(); }
1941 inline TraceCallStack& GetTextureTrace() { return mTextureTrace; }
1943 //Methods for Texture verification
1944 inline void EnableTexParameterCallTrace(bool enable) { mTexParamaterTrace.Enable(enable); }
1945 inline void ResetTexParameterCallStack() { mTexParamaterTrace.Reset(); }
1946 inline TraceCallStack& GetTexParameterTrace() { return mTexParamaterTrace; }
1948 //Methods for Draw verification
1949 inline void EnableDrawCallTrace(bool enable) { mDrawTrace.Enable(enable); }
1950 inline void ResetDrawCallStack() { mDrawTrace.Reset(); }
1951 inline TraceCallStack& GetDrawTrace() { return mDrawTrace; }
1953 //Methods for Depth function verification
1954 inline void EnableDepthFunctionCallTrace(bool enable) { mDepthFunctionTrace.Enable(enable); }
1955 inline void ResetDepthFunctionCallStack() { mDepthFunctionTrace.Reset(); }
1956 inline TraceCallStack& GetDepthFunctionTrace() { return mDepthFunctionTrace; }
1958 //Methods for Stencil function verification
1959 inline void EnableStencilFunctionCallTrace(bool enable) { mStencilFunctionTrace.Enable(enable); }
1960 inline void ResetStencilFunctionCallStack() { mStencilFunctionTrace.Reset(); }
1961 inline TraceCallStack& GetStencilFunctionTrace() { return mStencilFunctionTrace; }
1963 //Methods for Scissor verification
1964 inline void EnableScissorCallTrace(bool enable) { mScissorTrace.Enable(enable); }
1965 inline void ResetScissorCallStack() { mScissorTrace.Reset(); }
1966 inline TraceCallStack& GetScissorTrace() { return mScissorTrace; }
1968 //Methods for Uniform function verification
1969 inline void EnableSetUniformCallTrace(bool enable) { mSetUniformTrace.Enable(enable); }
1970 inline void ResetSetUniformCallStack() { mSetUniformTrace.Reset(); }
1971 inline TraceCallStack& GetSetUniformTrace() { return mSetUniformTrace; }
1973 template <typename T>
1974 inline bool GetUniformValue( const char* name, T& value ) const
1976 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
1977 program_it != mUniforms.end();
1980 const UniformIDMap &uniformIDs = program_it->second;
1982 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
1983 if( uniform_it != uniformIDs.end() )
1985 // found one matching uniform name, lets check the value...
1986 GLuint programId = program_it->first;
1987 GLint uniformId = uniform_it->second;
1989 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
1990 return mProgramUniforms.GetUniformValue( programId, uniformId, value );
1997 template <typename T>
1998 inline bool CheckUniformValue( const char* name, const T& value ) const
2000 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2001 program_it != mUniforms.end();
2004 const UniformIDMap &uniformIDs = program_it->second;
2006 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2007 if( uniform_it != uniformIDs.end() )
2009 // found one matching uniform name, lets check the value...
2010 GLuint programId = program_it->first;
2011 GLint uniformId = uniform_it->second;
2013 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
2014 if( mProgramUniforms.CheckUniformValue( programId, uniformId, value ) )
2016 // the value matches
2022 fprintf(stderr, "Not found, printing possible values:\n" );
2023 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2024 program_it != mUniforms.end();
2027 const UniformIDMap &uniformIDs = program_it->second;
2029 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2030 if( uniform_it != uniformIDs.end() )
2032 // found one matching uniform name, lets check the value...
2033 GLuint programId = program_it->first;
2034 GLint uniformId = uniform_it->second;
2036 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
2038 if ( mProgramUniforms.GetUniformValue(programId, uniformId, origValue) )
2040 std::stringstream out;
2041 out << uniform_it->first << ": " << origValue;
2042 fprintf(stderr, "%s\n", out.str().c_str() );
2049 template <typename T>
2050 inline bool GetUniformValue( GLuint programId, GLuint uniformId, T& outValue) const
2052 const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( outValue );
2053 return mProgramUniforms.GetUniformValue( programId, uniformId, outValue );
2056 inline bool GetUniformIds( const char* name, GLuint& programId, GLuint& uniformId ) const
2058 for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2059 program_it != mUniforms.end();
2062 const UniformIDMap &uniformIDs = program_it->second;
2064 UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
2065 if( uniform_it != uniformIDs.end() )
2067 programId = program_it->first;
2068 uniformId = uniform_it->second;
2075 inline GLuint GetLastShaderCompiled() const
2077 return mLastShaderCompiled;
2080 inline GLuint GetLastProgramCreated() const
2082 return mLastProgramIdUsed;
2085 inline GLbitfield GetLastClearMask() const
2087 return mLastClearBitMask;
2092 ATTRIB_UNKNOWN = -1,
2097 ATTRIB_BONE_WEIGHTS,
2098 ATTRIB_BONE_INDICES,
2102 struct ScissorParams
2109 ScissorParams() : x( 0 ), y( 0 ), width( 0 ), height( 0 ) { }
2112 // Methods to check scissor tests
2113 inline const ScissorParams& GetScissorParams() const { return mScissorParams; }
2115 struct ColorMaskParams
2122 ColorMaskParams() : red( true ), green( true ), blue( true ), alpha( true ) { }
2125 inline bool GetProgramBinaryCalled() const { return mGetProgramBinaryCalled; }
2127 inline unsigned int GetClearCountCalled() const { return mClearCount; }
2129 inline const ColorMaskParams& GetColorMaskParams() const { return mColorMaskParams; }
2131 typedef std::vector<size_t> BufferDataCalls;
2132 inline const BufferDataCalls& GetBufferDataCalls() const { return mBufferDataCalls; }
2133 inline void ResetBufferDataCalls() { mBufferDataCalls.clear(); }
2135 typedef std::vector<size_t> BufferSubDataCalls;
2136 inline const BufferSubDataCalls& GetBufferSubDataCalls() const { return mBufferSubDataCalls; }
2137 inline void ResetBufferSubDataCalls() { mBufferSubDataCalls.clear(); }
2140 GLuint mCurrentProgram;
2141 GLuint mCompileStatus;
2142 BufferDataCalls mBufferDataCalls;
2143 BufferSubDataCalls mBufferSubDataCalls;
2145 GLint mNumberOfActiveUniforms;
2146 GLint mGetAttribLocationResult;
2147 GLenum mGetErrorResult;
2148 GLubyte* mGetStringResult;
2149 GLboolean mIsBufferResult;
2150 GLboolean mIsEnabledResult;
2151 GLboolean mIsFramebufferResult;
2152 GLboolean mIsProgramResult;
2153 GLboolean mIsRenderbufferResult;
2154 GLboolean mIsShaderResult;
2155 GLboolean mIsTextureResult;
2156 GLenum mActiveTextureUnit;
2157 GLenum mCheckFramebufferStatusResult;
2158 GLint mFramebufferStatus;
2159 GLenum mFramebufferColorAttached;
2160 GLenum mFramebufferDepthAttached;
2161 GLenum mFramebufferStencilAttached;
2162 GLint mNumBinaryFormats;
2163 GLint mBinaryFormats;
2164 GLint mProgramBinaryLength;
2165 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2166 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2167 bool mGetProgramBinaryCalled;
2168 typedef std::map< GLuint, std::string> ShaderSourceMap;
2169 ShaderSourceMap mShaderSources;
2170 GLuint mLastShaderCompiled;
2171 GLbitfield mLastClearBitMask;
2172 unsigned int mClearCount;
2174 Vector4 mLastBlendColor;
2175 GLenum mLastBlendEquationRgb;
2176 GLenum mLastBlendEquationAlpha;
2177 GLenum mLastBlendFuncSrcRgb;
2178 GLenum mLastBlendFuncDstRgb;
2179 GLenum mLastBlendFuncSrcAlpha;
2180 GLenum mLastBlendFuncDstAlpha;
2182 GLboolean mLastDepthMask;
2184 // Data for manipulating the IDs returned by GenTextures
2185 GLuint mLastAutoTextureIdUsed;
2186 GLuint mNumGeneratedTextures;
2187 std::vector<GLuint> mNextTextureIds;
2188 std::vector<GLuint> mDeletedTextureIds;
2189 std::vector<GLuint> mBoundTextures;
2191 struct ActiveTextureType
2193 std::vector<GLuint> mBoundTextures;
2196 ActiveTextureType mActiveTextures[ MIN_TEXTURE_UNIT_LIMIT ];
2198 TraceCallStack mCullFaceTrace;
2199 TraceCallStack mEnableDisableTrace;
2200 TraceCallStack mShaderTrace;
2201 TraceCallStack mTextureTrace;
2202 TraceCallStack mTexParamaterTrace;
2203 TraceCallStack mDrawTrace;
2204 TraceCallStack mDepthFunctionTrace;
2205 TraceCallStack mStencilFunctionTrace;
2206 TraceCallStack mScissorTrace;
2207 TraceCallStack mSetUniformTrace;
2209 // Shaders & Uniforms
2210 GLuint mLastShaderIdUsed;
2211 GLuint mLastProgramIdUsed;
2212 GLuint mLastUniformIdUsed;
2213 typedef std::map< std::string, GLint > UniformIDMap;
2214 typedef std::map< GLuint, UniformIDMap > ProgramUniformMap;
2215 ProgramUniformMap mUniforms;
2217 template <typename T>
2218 struct ProgramUniformValue : public std::map< GLuint, std::map< GLint, T > >
2221 typedef std::map< GLint, T > UniformValueMap;
2222 typedef std::map< GLuint, UniformValueMap > Map;
2224 bool SetUniformValue( GLuint program, GLuint uniform, const T& value )
2231 typename Map::iterator it = Map::find( program );
2232 if( it == Map::end() )
2234 // if its the first uniform for this program add it
2235 std::pair< typename Map::iterator, bool > result =
2236 Map::insert( typename Map::value_type( program, UniformValueMap() ) );
2240 UniformValueMap& uniforms = it->second;
2241 uniforms[uniform] = value;
2246 bool CheckUniformValue( GLuint program, GLuint uniform, const T& value ) const
2249 if ( GetUniformValue( program, uniform, uniformValue ) )
2251 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2257 bool GetUniformValue( GLuint program, GLuint uniform, T& value ) const
2264 typename Map::const_iterator it = Map::find( program );
2265 if( it == Map::end() )
2267 // Uniform values always initialised as 0
2272 const UniformValueMap& uniforms = it->second;
2273 typename UniformValueMap::const_iterator it2 = uniforms.find( uniform );
2274 if( it2 == uniforms.end() )
2276 // Uniform values always initialised as 0
2280 value = it2->second;
2287 ProgramUniformValue<int> mProgramUniforms1i;
2288 ProgramUniformValue<float> mProgramUniforms1f;
2289 ProgramUniformValue<Vector2> mProgramUniforms2f;
2290 ProgramUniformValue<Vector3> mProgramUniforms3f;
2291 ProgramUniformValue<Vector4> mProgramUniforms4f;
2292 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2293 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2295 inline const ProgramUniformValue<int>& GetProgramUniformsForType( const int ) const
2297 return mProgramUniforms1i;
2299 inline const ProgramUniformValue<float>& GetProgramUniformsForType( const float ) const
2301 return mProgramUniforms1f;
2303 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType( const Vector2& ) const
2305 return mProgramUniforms2f;
2307 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType( const Vector3& ) const
2309 return mProgramUniforms3f;
2311 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType( const Vector4& ) const
2313 return mProgramUniforms4f;
2315 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType( const Matrix& ) const
2317 return mProgramUniformsMat4;
2319 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType( const Matrix3& ) const
2321 return mProgramUniformsMat3;
2323 inline void SetVertexAttribArray(GLuint index, bool state)
2325 if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
2330 mVertexAttribArrayState[ index ] = state;
2331 mVertexAttribArrayChanged = true;
2334 ScissorParams mScissorParams;
2335 ColorMaskParams mColorMaskParams;
2339 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2345 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2351 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2353 return Vector2::ZERO;
2357 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2359 return Vector3::ZERO;
2363 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2365 return Vector4::ZERO;
2369 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2375 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2377 return Matrix3( Matrix() );
2382 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2383 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2386 #endif // TEST_GL_ABSTRACTION_H