-#ifndef __TEST_GL_ABSTRACTION_H__
-#define __TEST_GL_ABSTRACTION_H__
-
-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+#ifndef TEST_GL_ABSTRACTION_H
+#define TEST_GL_ABSTRACTION_H
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
// EXTERNAL INCLUDES
#include <sstream>
#include <string>
+#include <cstring>
#include <map>
+#include <cstdio>
+#include <cstring> // for strcmp
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core-capi-internal.h>
#include <dali/public-api/dali-core.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/gl-abstraction.h>
+#include <dali/integration-api/gl-defines.h>
#include "test-trace-call-stack.h"
namespace Dali
~TestGlAbstraction();
void Initialize();
+ void PreRender();
+ void PostRender();
+
/* OpenGL ES 2.0 */
inline void ActiveTexture( GLenum textureUnit )
{
std::stringstream out;
out << program << ", " << shader;
- mShaderTrace.PushCall("AttachShader", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["program"] = ToString(program);
+ namedParams["shader"] = ToString(shader);
+ mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
}
inline void BindAttribLocation( GLuint program, GLuint index, const char* name )
inline void BindFramebuffer( GLenum target, GLuint framebuffer )
{
+ //Add 010 bit;
+ mFramebufferStatus |= 2;
}
inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
mActiveTextures[ mActiveTextureUnit ].mBoundTextures.push_back( texture );
}
}
+
+ std::stringstream out;
+ out << target << ", " << texture;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["texture"] = ToString(texture);
+
+ mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
}
inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
{
+ mBufferDataCalls.push_back(size);
}
inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
{
+ mBufferSubDataCalls.push_back(size);
}
inline GLenum CheckFramebufferStatus(GLenum target)
{
+ //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
+ //Framebuffer texture have been called
+ if( mFramebufferStatus == 7 )
+ {
+ return GL_FRAMEBUFFER_COMPLETE;
+ }
+
return mCheckFramebufferStatusResult;
}
+ inline GLenum CheckFramebufferColorAttachment()
+ {
+ return mFramebufferColorAttached;
+ }
+
+ inline GLenum CheckFramebufferDepthAttachment()
+ {
+ return mFramebufferDepthAttached;
+ }
+
+ inline GLenum CheckFramebufferStencilAttachment()
+ {
+ return mFramebufferStencilAttached;
+ }
+
inline void Clear(GLbitfield mask)
{
+ mClearCount++;
+ mLastClearBitMask = mask;
}
inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
inline void ClearStencil(GLint s)
{
+ std::stringstream out;
+ out << s;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["s"] = ToString( s );
+
+ mStencilFunctionTrace.PushCall( "ClearStencil", out.str(), namedParams );
}
inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
+ mColorMaskParams.red = red;
+ mColorMaskParams.green = green;
+ mColorMaskParams.blue = blue;
+ mColorMaskParams.alpha = alpha;
}
inline void CompileShader(GLuint shader)
{
std::stringstream out;
out << shader;
- mShaderTrace.PushCall("CompileShader", out.str());
+ TraceCallStack::NamedParams namedParams;
+ namedParams["shader"] = ToString(shader);
+
+ mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
}
inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
{
+ std::stringstream out;
+ out << target<<", "<<level<<", "<<width << ", " << height;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
+ namedParams["internalformat"] = ToString(internalformat);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ namedParams["border"] = ToString(border);
+ namedParams["size"] = ToString(imageSize);
+
+ mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
}
inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
{
+ std::stringstream out;
+ out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
+ namedParams["xoffset"] = ToString(xoffset);
+ namedParams["yoffset"] = ToString(yoffset);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
}
inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
std::stringstream out;
out << type;
- mShaderTrace.PushCall("CreateShader", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["type"] = ToString(type);
+ mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
return ++mLastShaderIdUsed;
}
{
std::stringstream out;
out << mode;
- mCullFaceTrace.PushCall("CullFace", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["program"] = ToString(mode);
+
+ mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
}
inline void DeleteBuffers(GLsizei n, const GLuint* buffers)
{
std::stringstream out;
out << program;
- mShaderTrace.PushCall("DeleteProgram", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["program"] = ToString(program);
+
+ mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
}
inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
std::stringstream out;
out << shader;
- mShaderTrace.PushCall("DeleteShader", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["shader"] = ToString(shader);
+
+ mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
}
inline void DeleteTextures(GLsizei n, const GLuint* textures)
{
std::stringstream out;
- out << n << ", " << textures << " = [" ;
+ out << n << ", " << textures << " = [";
+
+ TraceCallStack::NamedParams namedParams;
for(GLsizei i=0; i<n; i++)
{
- out << textures[i] << ", " ;
+ out << textures[i] << ", ";
+ std::stringstream paramName;
+ paramName<<"texture["<<i<<"]";
+ namedParams[paramName.str()] = ToString(textures[i]);
mDeletedTextureIds.push_back(textures[i]);
}
out << "]";
- mTextureTrace.PushCall("DeleteTextures", out.str());
+
+ mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
}
inline bool CheckNoTexturesDeleted()
inline void DepthFunc(GLenum func)
{
+ std::stringstream out;
+ out << func;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["func"] = ToString(func);
+
+ mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
}
inline void DepthMask(GLboolean flag)
{
+ mLastDepthMask = flag;
+ }
+
+ inline bool GetLastDepthMask() const
+ {
+ return mLastDepthMask;
}
inline void DepthRangef(GLclampf zNear, GLclampf zFar)
{
std::stringstream out;
out << program << ", " << shader;
- mShaderTrace.PushCall("DetachShader", out.str());
+ TraceCallStack::NamedParams namedParams;
+ namedParams["program"] = ToString(program);
+ namedParams["shader"] = ToString(shader);
+ mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
}
inline void Disable(GLenum cap)
{
std::stringstream out;
out << cap;
- mCullFaceTrace.PushCall("Disable", out.str());
+ TraceCallStack::NamedParams namedParams;
+ namedParams["cap"] = ToString(cap);
+ mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
}
inline void DisableVertexAttribArray(GLuint index)
{
std::stringstream out;
out << mode << ", " << first << ", " << count;
- mDrawTrace.PushCall("DrawArrays", out.str());
+ TraceCallStack::NamedParams namedParams;
+ namedParams["mode"] = ToString(mode);
+ namedParams["first"] = ToString(first);
+ namedParams["count"] = ToString(count);
+ mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
}
inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
{
std::stringstream out;
out << mode << ", " << count << ", " << type << ", indices";
- mDrawTrace.PushCall("DrawElements", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["mode"] = ToString(mode);
+ namedParams["count"] = ToString(count);
+ namedParams["type"] = ToString(type);
+ // Skip void pointers - are they of any use?
+ mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
}
inline void Enable(GLenum cap)
{
std::stringstream out;
out << cap;
- mCullFaceTrace.PushCall("Enable", out.str());
+ TraceCallStack::NamedParams namedParams;
+ namedParams["cap"] = ToString(cap);
+ mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
}
inline void EnableVertexAttribArray(GLuint index)
inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
+ if (attachment == GL_DEPTH_ATTACHMENT)
+ {
+ mFramebufferDepthAttached = true;
+ }
+ else if (attachment == GL_STENCIL_ATTACHMENT)
+ {
+ mFramebufferStencilAttached = true;
+ }
}
inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
+ //Add 100 bit;
+ mFramebufferStatus |= 4;
+
+ //We check 4 attachment colors
+ if ((attachment == GL_COLOR_ATTACHMENT0) || (attachment == GL_COLOR_ATTACHMENT1) || (attachment == GL_COLOR_ATTACHMENT2) || (attachment == GL_COLOR_ATTACHMENT4))
+ {
+ mFramebufferColorAttached = true;
+ }
}
inline void FrontFace(GLenum mode)
inline void GenerateMipmap(GLenum target)
{
+ std::stringstream out;
+ out<<target;
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+
+ mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
}
inline void GenFramebuffers(GLsizei n, GLuint* framebuffers)
{
+ for( int i = 0; i < n; i++ )
+ {
+ framebuffers[i] = i + 1;
+ }
+
+ //Add 001 bit, this function needs to be called the first one in the chain
+ mFramebufferStatus = 1;
}
inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
+ for( int i = 0; i < n; i++ )
+ {
+ renderbuffers[i] = i + 1;
+ }
}
/**
return mNextTextureIds;
}
- inline void GenTextures(GLsizei n, GLuint* textures)
+ inline void GenTextures(GLsizei count, GLuint* textures)
{
- for( int i=0; i<n; ++i )
+ for( int i=0; i<count; ++i )
{
if( !mNextTextureIds.empty() )
{
*(textures+i) = ++mLastAutoTextureIdUsed;
}
}
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["count"] = ToString(count);
+
+ std::stringstream out;
+ for(int i=0; i<count; i++)
+ {
+ out << textures[i];
+ if(i<count-1)
+ {
+ out << ", ";
+ }
+ std::ostringstream oss;
+ oss<<"indices["<<i<<"]";
+ namedParams[oss.str()] = ToString(textures[i]);
+ }
+
+ mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
}
inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
+ switch(index)
+ {
+ case 0:
+ *length = snprintf(name, bufsize, "sTexture");
+ *type = GL_SAMPLER_2D;
+ *size = 1;
+ break;
+ case 1:
+ *length = snprintf(name, bufsize, "sEffect");
+ *type = GL_SAMPLER_2D;
+ *size = 1;
+ break;
+ case 2:
+ *length = snprintf(name, bufsize, "sGloss");
+ *type = GL_SAMPLER_2D;
+ *size = 1;
+ break;
+ default:
+ break;
+ }
}
inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
inline void GetProgramiv(GLuint program, GLenum pname, GLint* params)
{
- switch( pname ) {
+ switch( pname )
+ {
case GL_LINK_STATUS:
*params = mLinkStatus;
break;
case GL_PROGRAM_BINARY_LENGTH_OES:
*params = mProgramBinaryLength;
break;
+ case GL_ACTIVE_UNIFORMS:
+ *params = mNumberOfActiveUniforms;
+ break;
+ case GL_ACTIVE_UNIFORM_MAX_LENGTH:
+ *params = 100;
+ break;
}
}
{
}
-
inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
}
{
std::stringstream out;
out << program;
- mShaderTrace.PushCall("LinkProgram", out.str());
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["program"] = ToString(program);
+ mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
+
+ mNumberOfActiveUniforms=3;
+ GetUniformLocation(program, "sTexture");
+ GetUniformLocation(program, "sEffect");
+ GetUniformLocation(program, "sGloss");
}
inline void PixelStorei(GLenum pname, GLint param)
inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
+ mScissorParams.x = x;
+ mScissorParams.y = y;
+ mScissorParams.width = width;
+ mScissorParams.height = height;
}
inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
}
}
+ inline std::string GetShaderSource(GLuint shader)
+ {
+ return mShaderSources[shader];
+ }
+
inline void StencilFunc(GLenum func, GLint ref, GLuint mask)
{
+ std::stringstream out;
+ out << func << ", " << ref << ", " << mask;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["func"] = ToString( func );
+ namedParams["ref"] = ToString( ref );
+ namedParams["mask"] = ToString( mask );
+
+ mStencilFunctionTrace.PushCall( "StencilFunc", out.str(), namedParams );
}
inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
+ std::stringstream out;
+ out << face << ", " << func << ", " << ref << ", " << mask;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["face"] = ToString( face );
+ namedParams["func"] = ToString( func );
+ namedParams["ref"] = ToString( ref );
+ namedParams["mask"] = ToString( mask );
+
+ mStencilFunctionTrace.PushCall( "StencilFuncSeparate", out.str(), namedParams );
}
inline void StencilMask(GLuint mask)
{
+ std::stringstream out;
+ out << mask;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["mask"] = ToString( mask );
+
+ mStencilFunctionTrace.PushCall( "StencilMask", out.str(), namedParams );
}
inline void StencilMaskSeparate(GLenum face, GLuint mask)
{
+ std::stringstream out;
+ out << face << ", " << mask;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["face"] = ToString( face );
+ namedParams["mask"] = ToString( mask );
+
+ mStencilFunctionTrace.PushCall( "StencilMaskSeparate", out.str(), namedParams );
}
inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
+ std::stringstream out;
+ out << fail << ", " << zfail << ", " << zpass;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["fail"] = ToString( fail );
+ namedParams["zfail"] = ToString( zfail );
+ namedParams["zpass"] = ToString( zpass );
+
+ mStencilFunctionTrace.PushCall( "StencilOp", out.str(), namedParams );
}
inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
+ std::stringstream out;
+ out << face << ", " << fail << ", " << zfail << "," << zpass;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["face"] = ToString( face );
+ namedParams["fail"] = ToString( fail );
+ namedParams["zfail"] = ToString( zfail );
+ namedParams["zpass"] = ToString( zpass );
+
+ mStencilFunctionTrace.PushCall( "StencilOpSeparate", out.str(), namedParams );
}
inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
{
std::stringstream out;
- out << width << ", " << height;
- mTextureTrace.PushCall("TexImage2D", out.str());
+ out << target<<", "<<level<<", "<<width << ", " << height;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
+ namedParams["internalformat"] = ToString(internalformat);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ namedParams["border"] = ToString(border);
+ namedParams["format"] = ToString(format);
+ namedParams["type"] = ToString(type);
+
+ mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
}
inline void TexParameterf(GLenum target, GLenum pname, GLfloat param)
{
+ std::stringstream out;
+ out << target << ", " << pname << ", " << param;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
+ namedParams["param"] = ToString(param);
+
+ mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
}
inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
{
+ std::stringstream out;
+ out << target << ", " << pname << ", " << params[0];
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
+ namedParams["params[0]"] = ToString(params[0]);
+
+ mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
}
inline void TexParameteri(GLenum target, GLenum pname, GLint param)
{
+ std::stringstream out;
+ out << target << ", " << pname << ", " << param;
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
+ namedParams["param"] = ToString(param);
+ mTexParamaterTrace.PushCall("TexParameteri", out.str(), namedParams);
}
inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
{
+ std::stringstream out;
+ out << target << ", " << pname << ", " << params[0];
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
+ namedParams["params[0]"] = ToString(params[0]);
+ mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
}
inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
{
std::stringstream out;
- out << xoffset << ", " << yoffset << ", " << width << ", " << height;
- mTextureTrace.PushCall("TexSubImage2D", out.str());
+ out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
+ namedParams["xoffset"] = ToString(xoffset);
+ namedParams["yoffset"] = ToString(yoffset);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
}
inline void Uniform1f(GLint location, GLfloat x)
inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
{
+ mGetProgramBinaryCalled = true;
}
inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
inline void ResetCullFaceCallStack() { mCullFaceTrace.Reset(); }
inline TraceCallStack& GetCullFaceTrace() { return mCullFaceTrace; }
+ //Methods for Enable/Disable call verification
+ inline void EnableEnableDisableCallTrace(bool enable) { mEnableDisableTrace.Enable(enable); }
+ inline void ResetEnableDisableCallStack() { mEnableDisableTrace.Reset(); }
+ inline TraceCallStack& GetEnableDisableTrace() { return mEnableDisableTrace; }
+
//Methods for Shader verification
inline void EnableShaderCallTrace(bool enable) { mShaderTrace.Enable(enable); }
inline void ResetShaderCallStack() { mShaderTrace.Reset(); }
inline void ResetTextureCallStack() { mTextureTrace.Reset(); }
inline TraceCallStack& GetTextureTrace() { return mTextureTrace; }
+ //Methods for Texture verification
+ inline void EnableTexParameterCallTrace(bool enable) { mTexParamaterTrace.Enable(enable); }
+ inline void ResetTexParameterCallStack() { mTexParamaterTrace.Reset(); }
+ inline TraceCallStack& GetTexParameterTrace() { return mTexParamaterTrace; }
+
//Methods for Draw verification
inline void EnableDrawCallTrace(bool enable) { mDrawTrace.Enable(enable); }
inline void ResetDrawCallStack() { mDrawTrace.Reset(); }
inline TraceCallStack& GetDrawTrace() { return mDrawTrace; }
+ //Methods for Depth function verification
+ inline void EnableDepthFunctionCallTrace(bool enable) { mDepthFunctionTrace.Enable(enable); }
+ inline void ResetDepthFunctionCallStack() { mDepthFunctionTrace.Reset(); }
+ inline TraceCallStack& GetDepthFunctionTrace() { return mDepthFunctionTrace; }
+
+ //Methods for Stencil function verification
+ inline void EnableStencilFunctionCallTrace(bool enable) { mStencilFunctionTrace.Enable(enable); }
+ inline void ResetStencilFunctionCallStack() { mStencilFunctionTrace.Reset(); }
+ inline TraceCallStack& GetStencilFunctionTrace() { return mStencilFunctionTrace; }
+
+ template <typename T>
+ inline bool GetUniformValue( const char* name, T& value ) const
+ {
+ for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
+ program_it != mUniforms.end();
+ ++program_it )
+ {
+ const UniformIDMap &uniformIDs = program_it->second;
+
+ UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
+ if( uniform_it != uniformIDs.end() )
+ {
+ // found one matching uniform name, lets check the value...
+ GLuint programId = program_it->first;
+ GLint uniformId = uniform_it->second;
+
+ const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
+ return mProgramUniforms.GetUniformValue( programId, uniformId, value );
+ }
+ }
+ return false;
+ }
+
+
template <typename T>
inline bool CheckUniformValue( const char* name, const T& value ) const
{
}
}
- fprintf(stderr, "Not found, printing possible values:" );
+ fprintf(stderr, "Not found, printing possible values:\n" );
for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
program_it != mUniforms.end();
++program_it )
{
std::stringstream out;
out << uniform_it->first << ": " << origValue;
- fprintf(stderr, "%s", out.str().c_str() );
+ fprintf(stderr, "%s\n", out.str().c_str() );
}
}
}
return false;
}
-
-
inline GLuint GetLastShaderCompiled() const
{
return mLastShaderCompiled;
return mLastProgramIdUsed;
}
+ inline GLbitfield GetLastClearMask() const
+ {
+ return mLastClearBitMask;
+ }
+
enum AttribType
{
ATTRIB_UNKNOWN = -1,
ATTRIB_TYPE_LAST
};
+ struct ScissorParams
+ {
+ GLint x;
+ GLint y;
+ GLsizei width;
+ GLsizei height;
+
+ ScissorParams() : x( 0 ), y( 0 ), width( 0 ), height( 0 ) { }
+ };
+
+ // Methods to check scissor tests
+ inline const ScissorParams& GetScissorParams() const { return mScissorParams; }
+
+ struct ColorMaskParams
+ {
+ GLboolean red;
+ GLboolean green;
+ GLboolean blue;
+ GLboolean alpha;
+
+ ColorMaskParams() : red( true ), green( true ), blue( true ), alpha( true ) { }
+ };
+
+ inline bool GetProgramBinaryCalled() const { return mGetProgramBinaryCalled; }
+
+ inline unsigned int GetClearCountCalled() const { return mClearCount; }
+
+ inline const ColorMaskParams& GetColorMaskParams() const { return mColorMaskParams; }
+
+ typedef std::vector<size_t> BufferDataCalls;
+ inline const BufferDataCalls& GetBufferDataCalls() const { return mBufferDataCalls; }
+ inline void ResetBufferDataCalls() { mBufferDataCalls.clear(); }
+
+ typedef std::vector<size_t> BufferSubDataCalls;
+ inline const BufferSubDataCalls& GetBufferSubDataCalls() const { return mBufferSubDataCalls; }
+ inline void ResetBufferSubDataCalls() { mBufferSubDataCalls.clear(); }
private:
GLuint mCurrentProgram;
GLuint mCompileStatus;
+ BufferDataCalls mBufferDataCalls;
+ BufferSubDataCalls mBufferSubDataCalls;
GLuint mLinkStatus;
+ GLint mNumberOfActiveUniforms;
GLint mGetAttribLocationResult;
GLenum mGetErrorResult;
GLubyte* mGetStringResult;
GLboolean mIsTextureResult;
GLenum mActiveTextureUnit;
GLenum mCheckFramebufferStatusResult;
+ GLint mFramebufferStatus;
+ GLenum mFramebufferColorAttached;
+ GLenum mFramebufferDepthAttached;
+ GLenum mFramebufferStencilAttached;
GLint mNumBinaryFormats;
GLint mBinaryFormats;
GLint mProgramBinaryLength;
bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
+ bool mGetProgramBinaryCalled;
typedef std::map< GLuint, std::string> ShaderSourceMap;
ShaderSourceMap mShaderSources;
GLuint mLastShaderCompiled;
+ GLbitfield mLastClearBitMask;
+ unsigned int mClearCount;
Vector4 mLastBlendColor;
GLenum mLastBlendEquationRgb;
GLenum mLastBlendFuncSrcAlpha;
GLenum mLastBlendFuncDstAlpha;
+ GLboolean mLastDepthMask;
+
// Data for manipulating the IDs returned by GenTextures
GLuint mLastAutoTextureIdUsed;
std::vector<GLuint> mNextTextureIds;
ActiveTextureType mActiveTextures[ MIN_TEXTURE_UNIT_LIMIT ];
TraceCallStack mCullFaceTrace;
+ TraceCallStack mEnableDisableTrace;
TraceCallStack mShaderTrace;
TraceCallStack mTextureTrace;
+ TraceCallStack mTexParamaterTrace;
TraceCallStack mDrawTrace;
+ TraceCallStack mDepthFunctionTrace;
+ TraceCallStack mStencilFunctionTrace;
// Shaders & Uniforms
GLuint mLastShaderIdUsed;
mVertexAttribArrayState[ index ] = state;
mVertexAttribArrayChanged = true;
}
+
+ ScissorParams mScissorParams;
+ ColorMaskParams mColorMaskParams;
};
template <>
bool BlendDisabled(const Dali::TraceCallStack& callStack);
-
-
-#endif // __TEST_GL_ES_H__
+#endif // TEST_GL_ABSTRACTION_H