1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
24 #include <cstring> // for strcmp
31 #include <dali/devel-api/rendering/frame-buffer-devel.h>
32 #include <dali/integration-api/core.h>
33 #include <dali/integration-api/gl-abstraction.h>
34 #include <dali/integration-api/gl-defines.h>
35 #include <dali/public-api/dali-core.h>
36 #include <test-compare-types.h>
37 #include <test-trace-call-stack.h>
45 UniformData(const std::string& name, Property::Type type = Property::Type::NONE)
52 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
55 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
58 ~TestGlAbstraction() override;
61 void PreRender() override;
62 void PostRender() override;
64 bool IsSurfacelessContextSupported() const override;
66 bool IsAdvancedBlendEquationSupported() override;
68 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
70 std::string GetShaderVersionPrefix();
72 std::string GetVertexShaderPrefix();
74 std::string GetFragmentShaderPrefix();
76 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
80 inline void ActiveTexture(GLenum textureUnit) override
82 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
85 inline GLenum GetActiveTextureUnit() const
87 return mActiveTextureUnit + GL_TEXTURE0;
90 inline void AttachShader(GLuint program, GLuint shader) override
92 std::stringstream out;
93 out << program << ", " << shader;
95 TraceCallStack::NamedParams namedParams;
96 namedParams["program"] << program;
97 namedParams["shader"] << shader;
98 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
101 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
105 inline void BindBuffer(GLenum target, GLuint buffer) override
107 std::ostringstream o;
108 o << std::hex << target << ", " << buffer;
109 TraceCallStack::NamedParams namedParams;
110 namedParams["target"] << target;
111 namedParams["buffer"] << buffer;
112 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
115 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
118 mFramebufferStatus |= 2;
121 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
126 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
127 * @return A vector containing the IDs that were bound.
129 inline const std::vector<GLuint>& GetBoundTextures() const
131 return mBoundTextures;
135 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
136 * @param[in] activeTextureUnit The specific active texture unit.
137 * @return A vector containing the IDs that were bound.
139 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
141 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
145 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
147 inline void ClearBoundTextures()
149 mBoundTextures.clear();
151 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
153 mActiveTextures[i].mBoundTextures.clear();
157 inline void BindTexture(GLenum target, GLuint texture) override
159 // Record the bound textures for future checks
162 mBoundTextures.push_back(texture);
164 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
166 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
170 std::stringstream out;
171 out << std::hex << target << ", " << std::dec << texture;
173 TraceCallStack::NamedParams namedParams;
174 namedParams["target"] << std::hex << target;
175 namedParams["texture"] << texture;
177 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
180 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
182 mLastBlendColor.r = red;
183 mLastBlendColor.g = green;
184 mLastBlendColor.b = blue;
185 mLastBlendColor.a = alpha;
188 inline const Vector4& GetLastBlendColor() const
190 return mLastBlendColor;
193 inline void BlendEquation(GLenum mode) override
195 mLastBlendEquationRgb = mode;
196 mLastBlendEquationAlpha = mode;
199 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
201 mLastBlendEquationRgb = modeRgb;
202 mLastBlendEquationAlpha = modeAlpha;
205 inline GLenum GetLastBlendEquationRgb() const
207 return mLastBlendEquationRgb;
210 inline GLenum GetLastBlendEquationAlpha() const
212 return mLastBlendEquationAlpha;
215 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
217 mLastBlendFuncSrcRgb = sfactor;
218 mLastBlendFuncDstRgb = dfactor;
219 mLastBlendFuncSrcAlpha = sfactor;
220 mLastBlendFuncDstAlpha = dfactor;
223 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
225 mLastBlendFuncSrcRgb = srcRGB;
226 mLastBlendFuncDstRgb = dstRGB;
227 mLastBlendFuncSrcAlpha = srcAlpha;
228 mLastBlendFuncDstAlpha = dstAlpha;
231 inline GLenum GetLastBlendFuncSrcRgb() const
233 return mLastBlendFuncSrcRgb;
236 inline GLenum GetLastBlendFuncDstRgb() const
238 return mLastBlendFuncDstRgb;
241 inline GLenum GetLastBlendFuncSrcAlpha() const
243 return mLastBlendFuncSrcAlpha;
246 inline GLenum GetLastBlendFuncDstAlpha() const
248 return mLastBlendFuncDstAlpha;
251 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
253 std::ostringstream o;
254 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
255 TraceCallStack::NamedParams namedParams;
256 namedParams["target"] << std::hex << target;
257 namedParams["size"] << size;
258 namedParams["usage"] << usage;
260 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
262 mBufferDataCalls.push_back(size);
265 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
267 std::ostringstream o;
268 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
269 TraceCallStack::NamedParams namedParams;
270 namedParams["target"] << std::hex << target;
271 namedParams["offset"] << offset;
272 namedParams["size"] << size;
273 mBufferTrace.PushCall("BufferSubData", o.str());
275 mBufferSubDataCalls.push_back(size);
278 inline GLenum CheckFramebufferStatus(GLenum target) override
280 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
281 //Framebuffer texture have been called
282 if(mFramebufferStatus == 7)
284 return GL_FRAMEBUFFER_COMPLETE;
287 return mCheckFramebufferStatusResult;
290 inline GLuint CheckFramebufferColorAttachmentCount()
292 return mFramebufferColorAttachmentCount;
295 inline GLenum CheckFramebufferDepthAttachment()
297 return mFramebufferDepthAttached;
300 inline GLenum CheckFramebufferStencilAttachment()
302 return mFramebufferStencilAttached;
305 inline void Clear(GLbitfield mask) override
308 mLastClearBitMask = mask;
311 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
313 mLastClearColor.r = red;
314 mLastClearColor.g = green;
315 mLastClearColor.b = blue;
316 mLastClearColor.a = alpha;
319 inline const Vector4& GetLastClearColor() const
321 return mLastClearColor;
324 inline void ClearDepthf(GLclampf depth) override
328 inline void ClearStencil(GLint s) override
330 std::stringstream out;
333 TraceCallStack::NamedParams namedParams;
334 namedParams["s"] << s;
336 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
339 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
341 mColorMaskParams.red = red;
342 mColorMaskParams.green = green;
343 mColorMaskParams.blue = blue;
344 mColorMaskParams.alpha = alpha;
347 inline void CompileShader(GLuint shader) override
349 std::stringstream out;
351 TraceCallStack::NamedParams namedParams;
352 namedParams["shader"] << shader;
354 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
357 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
359 std::stringstream out;
360 out << target << ", " << level << ", " << width << ", " << height;
362 TraceCallStack::NamedParams namedParams;
363 namedParams["target"] << std::hex << target;
364 namedParams["level"] << level;
365 namedParams["internalformat"] << internalformat;
366 namedParams["width"] << width;
367 namedParams["height"] << height;
368 namedParams["border"] << border;
369 namedParams["size"] << imageSize;
371 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
374 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
376 std::stringstream out;
377 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
379 TraceCallStack::NamedParams namedParams;
380 namedParams["target"] << std::hex << target;
381 namedParams["level"] << level;
382 namedParams["xoffset"] << xoffset;
383 namedParams["yoffset"] << yoffset;
384 namedParams["width"] << width;
385 namedParams["height"] << height;
386 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
389 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
393 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
397 inline GLuint CreateProgram(void) override
399 mShaderTrace.PushCall("CreateProgram", "");
401 ++mLastProgramIdUsed;
402 mUniforms[mLastProgramIdUsed] = UniformIDMap();
403 return mLastProgramIdUsed;
406 inline GLuint CreateShader(GLenum type) override
408 std::stringstream out;
411 TraceCallStack::NamedParams namedParams;
412 namedParams["type"] << std::hex << type;
413 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
415 return ++mLastShaderIdUsed;
418 inline void CullFace(GLenum mode) override
420 std::stringstream out;
421 out << std::hex << mode;
423 TraceCallStack::NamedParams namedParams;
424 namedParams["mode"] << std::hex << mode;
426 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
429 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
433 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
437 inline void DeleteProgram(GLuint program) override
439 std::stringstream out;
442 TraceCallStack::NamedParams namedParams;
443 namedParams["program"] << program;
445 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
448 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
452 inline void DeleteShader(GLuint shader) override
454 std::stringstream out;
457 TraceCallStack::NamedParams namedParams;
458 namedParams["shader"] << shader;
460 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
463 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
465 std::stringstream out;
466 out << "n:" << n << " textures[";
468 TraceCallStack::NamedParams namedParams;
470 for(GLsizei i = 0; i < n; i++)
472 out << (i > 0 ? ", " : "") << textures[i];
473 std::stringstream paramName;
474 paramName << "texture[" << i << "]";
475 namedParams[paramName.str()] << textures[i];
476 mDeletedTextureIds.push_back(textures[i]);
477 mNumGeneratedTextures--;
481 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
484 inline bool CheckNoTexturesDeleted()
486 return mDeletedTextureIds.size() == 0;
489 inline bool CheckTextureDeleted(GLuint textureId)
493 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
495 if(*iter == textureId)
504 inline void ClearDeletedTextures()
506 mDeletedTextureIds.clear();
509 inline void DepthFunc(GLenum func) override
511 std::stringstream out;
512 out << std::hex << func;
514 TraceCallStack::NamedParams namedParams;
515 namedParams["func"] << std::hex << func;
517 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
520 inline void DepthMask(GLboolean flag) override
522 mLastDepthMask = flag;
525 inline bool GetLastDepthMask() const
527 return mLastDepthMask;
530 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
534 inline void DetachShader(GLuint program, GLuint shader) override
536 std::stringstream out;
537 out << program << ", " << shader;
538 TraceCallStack::NamedParams namedParams;
539 namedParams["program"] << program;
540 namedParams["shader"] << shader;
541 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
544 inline void Disable(GLenum cap) override
546 std::stringstream out;
547 out << std::hex << cap;
548 TraceCallStack::NamedParams namedParams;
549 namedParams["cap"] << std::hex << cap;
550 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
553 inline void DisableVertexAttribArray(GLuint index) override
555 std::stringstream out;
557 TraceCallStack::NamedParams namedParams;
558 namedParams["index"] << index;
559 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
560 SetVertexAttribArray(index, false);
563 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
565 std::stringstream out;
566 out << mode << ", " << first << ", " << count;
567 TraceCallStack::NamedParams namedParams;
568 namedParams["mode"] << std::hex << mode;
569 namedParams["first"] << first;
570 namedParams["count"] << count;
571 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
574 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
576 std::stringstream out;
577 out << mode << ", " << count << ", " << type << ", indices";
579 TraceCallStack::NamedParams namedParams;
580 namedParams["mode"] << std::hex << mode;
581 namedParams["count"] << count;
582 namedParams["type"] << type;
583 // Skip void pointers - are they of any use?
584 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
587 inline void Enable(GLenum cap) override
589 std::stringstream out;
590 out << std::hex << cap;
591 TraceCallStack::NamedParams namedParams;
592 namedParams["cap"] << std::hex << cap;
593 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
596 inline void EnableVertexAttribArray(GLuint index) override
598 std::stringstream out;
600 TraceCallStack::NamedParams namedParams;
601 namedParams["index"] << index;
602 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
603 SetVertexAttribArray(index, true);
606 inline void Finish(void) override
610 inline void Flush(void) override
614 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
616 if(attachment == GL_DEPTH_ATTACHMENT)
618 mFramebufferDepthAttached = true;
620 else if(attachment == GL_STENCIL_ATTACHMENT)
622 mFramebufferStencilAttached = true;
626 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
629 mFramebufferStatus |= 4;
631 //We check 4 attachment colors
632 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
634 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
635 if((mFrameBufferColorStatus & mask) == 0)
637 mFrameBufferColorStatus |= mask;
638 ++mFramebufferColorAttachmentCount;
643 inline void FrontFace(GLenum mode) override
648 inline void GenBuffers(GLsizei n, GLuint* buffers) override
650 // avoids an assert in GpuBuffers
653 std::ostringstream o;
655 TraceCallStack::NamedParams namedParams;
656 namedParams["n"] << o.str();
657 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
660 inline void GenerateMipmap(GLenum target) override
662 std::stringstream out;
664 TraceCallStack::NamedParams namedParams;
665 namedParams["target"] << std::hex << target;
667 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
670 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
672 for(int i = 0; i < n; i++)
674 framebuffers[i] = i + 1;
677 //Add 001 bit, this function needs to be called the first one in the chain
678 mFramebufferStatus = 1;
681 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
683 for(int i = 0; i < n; i++)
685 renderbuffers[i] = i + 1;
690 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
691 * @param[in] ids A vector containing the next IDs to be generated
693 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
695 mNextTextureIds = ids;
698 inline const std::vector<GLuint>& GetNextTextureIds()
700 return mNextTextureIds;
703 inline void GenTextures(GLsizei count, GLuint* textures) override
705 for(int i = 0; i < count; ++i)
707 if(!mNextTextureIds.empty())
709 *(textures + i) = mNextTextureIds[0];
710 mNextTextureIds.erase(mNextTextureIds.begin());
714 *(textures + i) = ++mLastAutoTextureIdUsed;
716 mNumGeneratedTextures++;
719 TraceCallStack::NamedParams namedParams;
720 namedParams["count"] << count;
722 std::stringstream out;
723 for(int i = 0; i < count; i++)
730 std::ostringstream oss;
731 oss << "indices[" << i << "]";
732 namedParams[oss.str()] << textures[i];
735 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
738 inline GLuint GetLastGenTextureId()
740 return mLastAutoTextureIdUsed;
743 inline GLuint GetNumGeneratedTextures()
745 return mNumGeneratedTextures;
748 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
752 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
757 *length = snprintf(name, bufsize, "sTexture");
758 *type = GL_SAMPLER_2D;
762 *length = snprintf(name, bufsize, "sEffect");
763 *type = GL_SAMPLER_2D;
767 *length = snprintf(name, bufsize, "sGloss");
768 *type = GL_SAMPLER_2D;
776 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
780 inline int GetAttribLocation(GLuint program, const char* name) override
782 std::string check(name);
783 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
784 if(iter == mAttribLocs.end())
786 return iter - mAttribLocs.begin();
789 inline void GetBooleanv(GLenum pname, GLboolean* params) override
793 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
797 inline GLenum GetError(void) override
799 return mGetErrorResult;
802 inline void GetFloatv(GLenum pname, GLfloat* params) override
806 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
810 inline void GetIntegerv(GLenum pname, GLint* params) override
814 case GL_MAX_TEXTURE_SIZE:
817 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
820 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
821 *params = mNumBinaryFormats;
823 case GL_PROGRAM_BINARY_FORMATS_OES:
824 *params = mBinaryFormats;
829 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
834 *params = mLinkStatus;
836 case GL_PROGRAM_BINARY_LENGTH_OES:
837 *params = mProgramBinaryLength;
839 case GL_ACTIVE_UNIFORMS:
840 *params = mNumberOfActiveUniforms;
842 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
845 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
851 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
855 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
859 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
863 case GL_COMPILE_STATUS:
864 *params = mCompileStatus;
869 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
873 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
877 inline const GLubyte* GetString(GLenum name) override
879 return mGetStringResult;
882 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
886 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
890 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
894 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
898 inline GLint GetUniformLocation(GLuint program, const char* name) override
900 ProgramUniformMap::iterator it = mUniforms.find(program);
901 if(it == mUniforms.end())
903 // Not a valid program ID
904 mGetErrorResult = GL_INVALID_OPERATION;
908 UniformIDMap& uniformIDs = it->second;
909 UniformIDMap::iterator it2 = uniformIDs.find(name);
910 if(it2 == uniformIDs.end())
912 // Uniform not found, so add it...
913 uniformIDs[name] = mLastUniformIdUsed++;
914 return mLastUniformIdUsed;
920 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
924 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
928 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
932 inline void Hint(GLenum target, GLenum mode) override
936 inline GLboolean IsBuffer(GLuint buffer) override
938 return mIsBufferResult;
941 inline GLboolean IsEnabled(GLenum cap) override
943 return mIsEnabledResult;
946 inline GLboolean IsFramebuffer(GLuint framebuffer) override
948 return mIsFramebufferResult;
951 inline GLboolean IsProgram(GLuint program) override
953 return mIsProgramResult;
956 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
958 return mIsRenderbufferResult;
961 inline GLboolean IsShader(GLuint shader) override
963 return mIsShaderResult;
966 inline GLboolean IsTexture(GLuint texture) override
968 return mIsTextureResult;
971 inline void LineWidth(GLfloat width) override
975 inline void LinkProgram(GLuint program) override
977 std::stringstream out;
980 TraceCallStack::NamedParams namedParams;
981 namedParams["program"] << program;
982 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
984 mNumberOfActiveUniforms = 3;
986 GetUniformLocation(program, "uRendererColor");
987 GetUniformLocation(program, "uCustom");
988 GetUniformLocation(program, "uCustom3");
989 GetUniformLocation(program, "uFadeColor");
990 GetUniformLocation(program, "uUniform1");
991 GetUniformLocation(program, "uUniform2");
992 GetUniformLocation(program, "uUniform3");
993 GetUniformLocation(program, "uFadeProgress");
994 GetUniformLocation(program, "uANormalMatrix");
995 GetUniformLocation(program, "sEffect");
996 GetUniformLocation(program, "sTexture");
997 GetUniformLocation(program, "sTextureRect");
998 GetUniformLocation(program, "sGloss");
999 GetUniformLocation(program, "uColor");
1000 GetUniformLocation(program, "uModelMatrix");
1001 GetUniformLocation(program, "uModelView");
1002 GetUniformLocation(program, "uMvpMatrix");
1003 GetUniformLocation(program, "uNormalMatrix");
1004 GetUniformLocation(program, "uProjection");
1005 GetUniformLocation(program, "uSize");
1006 GetUniformLocation(program, "uViewMatrix");
1007 GetUniformLocation(program, "uLightCameraProjectionMatrix");
1008 GetUniformLocation(program, "uLightCameraViewMatrix");
1010 for(const auto& uniform : mCustomUniformData)
1012 GetUniformLocation(program, uniform.name.c_str());
1016 inline void PixelStorei(GLenum pname, GLint param) override
1020 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1024 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1028 inline void ReleaseShaderCompiler(void) override
1032 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1036 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1040 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1042 mScissorParams.x = x;
1043 mScissorParams.y = y;
1044 mScissorParams.width = width;
1045 mScissorParams.height = height;
1047 std::stringstream out;
1048 out << x << ", " << y << ", " << width << ", " << height;
1049 TraceCallStack::NamedParams namedParams;
1050 namedParams["x"] << x;
1051 namedParams["y"] << y;
1052 namedParams["width"] << width;
1053 namedParams["height"] << height;
1054 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1057 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1061 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1063 std::string stringBuilder;
1064 for(int i = 0; i < count; ++i)
1066 stringBuilder += string[i];
1068 mShaderSources[shader] = stringBuilder;
1069 mLastShaderCompiled = shader;
1072 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1074 const std::string shaderSource = mShaderSources[shader];
1075 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1076 if(shaderSourceLength < bufsize)
1078 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1079 *length = shaderSourceLength;
1083 *length = bufsize - 1;
1084 strncpy(source, shaderSource.c_str(), *length);
1085 source[*length] = 0x0;
1089 inline std::string GetShaderSource(GLuint shader)
1091 return mShaderSources[shader];
1094 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1096 std::stringstream out;
1097 out << func << ", " << ref << ", " << mask;
1099 TraceCallStack::NamedParams namedParams;
1100 namedParams["func"] << std::hex << func;
1101 namedParams["ref"] << ref;
1102 namedParams["mask"] << mask;
1104 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1107 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1109 std::stringstream out;
1110 out << face << ", " << func << ", " << ref << ", " << mask;
1112 TraceCallStack::NamedParams namedParams;
1113 namedParams["face"] << std::hex << face;
1114 namedParams["func"] << std::hex << func;
1115 namedParams["ref"] << ref;
1116 namedParams["mask"] << mask;
1118 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1121 inline void StencilMask(GLuint mask) override
1123 std::stringstream out;
1126 TraceCallStack::NamedParams namedParams;
1127 namedParams["mask"] << mask;
1129 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1132 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1134 std::stringstream out;
1135 out << face << ", " << mask;
1137 TraceCallStack::NamedParams namedParams;
1138 namedParams["face"] << std::hex << face;
1139 namedParams["mask"] << mask;
1141 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1144 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1146 std::stringstream out;
1147 out << fail << ", " << zfail << ", " << zpass;
1149 TraceCallStack::NamedParams namedParams;
1150 namedParams["fail"] << std::hex << fail;
1151 namedParams["zfail"] << std::hex << zfail;
1152 namedParams["zpass"] << std::hex << zpass;
1154 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1157 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1159 std::stringstream out;
1160 out << face << ", " << fail << ", " << zfail << "," << zpass;
1162 TraceCallStack::NamedParams namedParams;
1163 namedParams["face"] << std::hex << face;
1164 namedParams["fail"] << std::hex << fail;
1165 namedParams["zfail"] << std::hex << zfail;
1166 namedParams["zpass"] << std::hex << zpass;
1168 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1171 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1173 std::stringstream out;
1174 out << target << ", " << level << ", " << width << ", " << height;
1176 TraceCallStack::NamedParams namedParams;
1177 namedParams["target"] << std::hex << target;
1178 namedParams["level"] << level;
1179 namedParams["internalformat"] << internalformat;
1180 namedParams["width"] << width;
1181 namedParams["height"] << height;
1182 namedParams["border"] << border;
1183 namedParams["format"] << std::hex << format;
1184 namedParams["type"] << std::hex << type;
1186 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1189 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1191 std::stringstream out;
1192 out << target << ", " << pname << ", " << param;
1194 TraceCallStack::NamedParams namedParams;
1195 namedParams["target"] << std::hex << target;
1196 namedParams["pname"] << std::hex << pname;
1197 namedParams["param"] << param;
1199 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1202 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1204 std::stringstream out;
1205 out << target << ", " << pname << ", " << params[0];
1207 TraceCallStack::NamedParams namedParams;
1208 namedParams["target"] << std::hex << target;
1209 namedParams["pname"] << std::hex << pname;
1210 namedParams["params[0]"] << params[0];
1212 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1215 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1217 std::stringstream out;
1218 out << std::hex << target << ", " << pname << ", " << param;
1219 std::string params = out.str();
1221 TraceCallStack::NamedParams namedParams;
1222 namedParams["target"] << std::hex << target;
1223 namedParams["pname"] << std::hex << pname;
1224 namedParams["param"] << param;
1225 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1228 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1230 std::stringstream out;
1231 out << target << ", " << pname << ", " << params[0];
1232 TraceCallStack::NamedParams namedParams;
1233 namedParams["target"] << std::hex << target;
1234 namedParams["pname"] << std::hex << pname;
1235 namedParams["params[0]"] << params[0];
1236 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1239 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1241 std::stringstream out;
1242 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1244 TraceCallStack::NamedParams namedParams;
1245 namedParams["target"] << std::hex << target;
1246 namedParams["level"] << level;
1247 namedParams["xoffset"] << xoffset;
1248 namedParams["yoffset"] << yoffset;
1249 namedParams["width"] << width;
1250 namedParams["height"] << height;
1251 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1254 inline void Uniform1f(GLint location, GLfloat value) override
1256 std::string params = std::to_string(value);
1257 AddUniformCallToTraceStack(location, params);
1259 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1261 mGetErrorResult = GL_INVALID_OPERATION;
1265 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1268 for(int i = 0; i < count; ++i)
1270 params = params + std::to_string(v[i]) + ",";
1273 AddUniformCallToTraceStack(location, params);
1275 for(int i = 0; i < count; ++i)
1277 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1279 mGetErrorResult = GL_INVALID_OPERATION;
1285 inline void Uniform1i(GLint location, GLint x) override
1287 std::string params = std::to_string(x);
1289 AddUniformCallToTraceStack(location, params);
1291 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1293 mGetErrorResult = GL_INVALID_OPERATION;
1297 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1299 std::ostringstream out;
1300 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1301 AddUniformCallToTraceStack(location, out.str());
1303 for(int i = 0; i < count; ++i)
1305 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1309 mGetErrorResult = GL_INVALID_OPERATION;
1315 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1317 std::string params = std::to_string(x) + "," + std::to_string(y);
1318 AddUniformCallToTraceStack(location, params);
1320 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1324 mGetErrorResult = GL_INVALID_OPERATION;
1328 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1330 std::ostringstream out;
1331 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1332 AddUniformCallToTraceStack(location, out.str());
1334 for(int i = 0; i < count; ++i)
1336 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1338 Vector2(v[2 * i], v[2 * i + 1])))
1340 mGetErrorResult = GL_INVALID_OPERATION;
1346 inline void Uniform2i(GLint location, GLint x, GLint y) override
1348 std::string params = std::to_string(x) + "," + std::to_string(y);
1349 AddUniformCallToTraceStack(location, params);
1352 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1354 std::ostringstream out;
1355 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1356 AddUniformCallToTraceStack(location, out.str());
1359 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1361 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1362 AddUniformCallToTraceStack(location, params);
1364 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1368 mGetErrorResult = GL_INVALID_OPERATION;
1372 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1374 std::ostringstream out;
1375 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1376 AddUniformCallToTraceStack(location, out.str());
1378 for(int i = 0; i < count; ++i)
1380 if(!mProgramUniforms3f.SetUniformValue(
1383 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1385 mGetErrorResult = GL_INVALID_OPERATION;
1391 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1393 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1394 AddUniformCallToTraceStack(location, params);
1397 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1399 std::ostringstream out;
1400 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1401 AddUniformCallToTraceStack(location, out.str());
1404 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1406 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1407 AddUniformCallToTraceStack(location, params);
1409 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1411 Vector4(x, y, z, w)))
1413 mGetErrorResult = GL_INVALID_OPERATION;
1417 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1419 std::ostringstream out;
1420 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1421 AddUniformCallToTraceStack(location, out.str());
1423 for(int i = 0; i < count; ++i)
1425 if(!mProgramUniforms4f.SetUniformValue(
1428 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1430 mGetErrorResult = GL_INVALID_OPERATION;
1436 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1438 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1439 AddUniformCallToTraceStack(location, params);
1442 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1444 std::ostringstream out;
1445 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1446 AddUniformCallToTraceStack(location, out.str());
1449 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1451 std::ostringstream out;
1452 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1453 AddUniformCallToTraceStack(location, out.str());
1456 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1458 std::ostringstream out;
1459 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1460 AddUniformCallToTraceStack(location, out.str());
1462 for(int i = 0; i < count; ++i)
1464 if(!mProgramUniformsMat3.SetUniformValue(
1467 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1469 mGetErrorResult = GL_INVALID_OPERATION;
1475 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1477 std::ostringstream out;
1478 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1479 AddUniformCallToTraceStack(location, out.str());
1481 for(int i = 0; i < count; ++i)
1483 if(!mProgramUniformsMat4.SetUniformValue(
1488 mGetErrorResult = GL_INVALID_OPERATION;
1494 inline void UseProgram(GLuint program) override
1496 mCurrentProgram = program;
1499 inline void ValidateProgram(GLuint program) override
1503 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1507 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1511 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1515 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1519 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1523 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1527 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1531 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1535 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1537 TraceCallStack::NamedParams namedParams;
1538 namedParams["index"] << index;
1539 namedParams["size"] << size;
1540 namedParams["type"] << std::hex << type;
1541 namedParams["normalized"] << (normalized ? "T" : "F");
1542 namedParams["stride"] << stride;
1543 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1545 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1548 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1550 std::string commaString(", ");
1551 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1553 mViewportTrace.PushCall("Viewport", params);
1558 inline void ReadBuffer(GLenum mode) override
1562 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1566 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
1570 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
1574 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1578 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1582 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
1586 inline void GenQueries(GLsizei n, GLuint* ids) override
1590 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1594 inline GLboolean IsQuery(GLuint id) override
1599 inline void BeginQuery(GLenum target, GLuint id) override
1603 inline void EndQuery(GLenum target) override
1607 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1611 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1615 inline GLboolean UnmapBuffer(GLenum target) override
1619 free(mMappedBuffer);
1620 mMappedBuffer = nullptr;
1622 return true; // false indicates corruption, nothing else.
1625 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1629 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1633 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1637 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1641 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1645 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1649 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1653 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1657 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1661 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1665 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1669 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1671 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1672 return mMappedBuffer;
1675 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1679 inline void BindVertexArray(GLuint array) override
1683 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1687 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1691 inline GLboolean IsVertexArray(GLuint array) override
1696 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1700 inline void BeginTransformFeedback(GLenum primitiveMode) override
1704 inline void EndTransformFeedback(void) override
1708 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1712 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1716 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1720 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1724 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1728 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1732 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1736 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1740 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1744 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1748 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1752 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1756 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1761 inline void Uniform1ui(GLint location, GLuint v0) override
1765 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1769 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1773 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1777 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1781 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1785 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1789 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1793 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1797 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1801 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1805 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1809 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1814 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1818 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1822 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1826 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1828 return GL_INVALID_INDEX;
1831 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1835 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1839 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1843 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1847 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1851 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1856 inline GLboolean IsSync(GLsync sync) override
1861 inline void DeleteSync(GLsync sync) override
1865 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1870 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1874 inline void GetInteger64v(GLenum pname, GLint64* params) override
1878 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1882 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1886 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1890 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1894 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1898 inline GLboolean IsSampler(GLuint sampler) override
1903 inline void BindSampler(GLuint unit, GLuint sampler) override
1907 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1911 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1915 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1919 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1923 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1927 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1931 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1935 inline void BindTransformFeedback(GLenum target, GLuint id) override
1939 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1943 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1947 inline GLboolean IsTransformFeedback(GLuint id) override
1952 inline void PauseTransformFeedback(void) override
1956 inline void ResumeTransformFeedback(void) override
1960 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1962 mGetProgramBinaryCalled = true;
1965 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1969 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1973 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1977 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1981 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1985 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1989 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1993 inline void BlendBarrier(void)
1998 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2000 std::string name = "<not found>";
2001 bool matched = false;
2003 UniformIDMap& map = mUniforms[mCurrentProgram];
2004 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2006 if(it->second == location)
2016 mSetUniformTrace.PushCall(name, value);
2020 public: // TEST FUNCTIONS
2021 inline void SetCompileStatus(GLuint value)
2023 mCompileStatus = value;
2025 inline void SetLinkStatus(GLuint value)
2027 mLinkStatus = value;
2029 inline void SetAttribLocations(std::vector<std::string> locs)
2033 inline void SetGetErrorResult(GLenum result)
2035 mGetErrorResult = result;
2037 inline void SetGetStringResult(GLubyte* result)
2039 mGetStringResult = result;
2041 inline void SetIsBufferResult(GLboolean result)
2043 mIsBufferResult = result;
2045 inline void SetIsEnabledResult(GLboolean result)
2047 mIsEnabledResult = result;
2049 inline void SetIsFramebufferResult(GLboolean result)
2051 mIsFramebufferResult = result;
2053 inline void SetIsProgramResult(GLboolean result)
2055 mIsProgramResult = result;
2057 inline void SetIsRenderbufferResult(GLboolean result)
2059 mIsRenderbufferResult = result;
2061 inline void SetIsShaderResult(GLboolean result)
2063 mIsShaderResult = result;
2065 inline void SetIsTextureResult(GLboolean result)
2067 mIsTextureResult = result;
2069 inline void SetCheckFramebufferStatusResult(GLenum result)
2071 mCheckFramebufferStatusResult = result;
2073 inline void SetNumBinaryFormats(GLint numFormats)
2075 mNumBinaryFormats = numFormats;
2077 inline void SetBinaryFormats(GLint binaryFormats)
2079 mBinaryFormats = binaryFormats;
2081 inline void SetProgramBinaryLength(GLint length)
2083 mProgramBinaryLength = length;
2086 inline bool GetVertexAttribArrayState(GLuint index)
2088 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2093 return mVertexAttribArrayState[index];
2095 inline void ClearVertexAttribArrayChanged()
2097 mVertexAttribArrayChanged = false;
2099 inline bool GetVertexAttribArrayChanged()
2101 return mVertexAttribArrayChanged;
2104 //Methods for CullFace verification
2105 inline void EnableCullFaceCallTrace(bool enable)
2107 mCullFaceTrace.Enable(enable);
2109 inline void ResetCullFaceCallStack()
2111 mCullFaceTrace.Reset();
2113 inline TraceCallStack& GetCullFaceTrace()
2115 return mCullFaceTrace;
2118 //Methods for Enable/Disable call verification
2119 inline void EnableEnableDisableCallTrace(bool enable)
2121 mEnableDisableTrace.Enable(enable);
2123 inline void ResetEnableDisableCallStack()
2125 mEnableDisableTrace.Reset();
2127 inline TraceCallStack& GetEnableDisableTrace()
2129 return mEnableDisableTrace;
2132 //Methods for Shader verification
2133 inline void EnableShaderCallTrace(bool enable)
2135 mShaderTrace.Enable(enable);
2137 inline void ResetShaderCallStack()
2139 mShaderTrace.Reset();
2141 inline TraceCallStack& GetShaderTrace()
2143 return mShaderTrace;
2146 //Methods for Texture verification
2147 inline void EnableTextureCallTrace(bool enable)
2149 mTextureTrace.Enable(enable);
2151 inline void ResetTextureCallStack()
2153 mTextureTrace.Reset();
2155 inline TraceCallStack& GetTextureTrace()
2157 return mTextureTrace;
2160 //Methods for Texture verification
2161 inline void EnableTexParameterCallTrace(bool enable)
2163 mTexParameterTrace.Enable(enable);
2165 inline void ResetTexParameterCallStack()
2167 mTexParameterTrace.Reset();
2169 inline TraceCallStack& GetTexParameterTrace()
2171 return mTexParameterTrace;
2174 //Methods for Draw verification
2175 inline void EnableDrawCallTrace(bool enable)
2177 mDrawTrace.Enable(enable);
2179 inline void ResetDrawCallStack()
2183 inline TraceCallStack& GetDrawTrace()
2188 //Methods for Depth function verification
2189 inline void EnableDepthFunctionCallTrace(bool enable)
2191 mDepthFunctionTrace.Enable(enable);
2193 inline void ResetDepthFunctionCallStack()
2195 mDepthFunctionTrace.Reset();
2197 inline TraceCallStack& GetDepthFunctionTrace()
2199 return mDepthFunctionTrace;
2202 //Methods for Stencil function verification
2203 inline void EnableStencilFunctionCallTrace(bool enable)
2205 mStencilFunctionTrace.Enable(enable);
2207 inline void ResetStencilFunctionCallStack()
2209 mStencilFunctionTrace.Reset();
2211 inline TraceCallStack& GetStencilFunctionTrace()
2213 return mStencilFunctionTrace;
2216 //Methods for Scissor verification
2217 inline void EnableScissorCallTrace(bool enable)
2219 mScissorTrace.Enable(enable);
2221 inline void ResetScissorCallStack()
2223 mScissorTrace.Reset();
2225 inline TraceCallStack& GetScissorTrace()
2227 return mScissorTrace;
2230 //Methods for Uniform function verification
2231 inline void EnableSetUniformCallTrace(bool enable)
2233 mSetUniformTrace.Enable(enable);
2235 inline void ResetSetUniformCallStack()
2237 mSetUniformTrace.Reset();
2239 inline TraceCallStack& GetSetUniformTrace()
2241 return mSetUniformTrace;
2244 //Methods for Viewport verification
2245 inline void EnableViewportCallTrace(bool enable)
2247 mViewportTrace.Enable(enable);
2249 inline void ResetViewportCallStack()
2251 mViewportTrace.Reset();
2253 inline TraceCallStack& GetViewportTrace()
2255 return mViewportTrace;
2257 inline TraceCallStack& GetBufferTrace()
2259 return mBufferTrace;
2262 template<typename T>
2263 inline bool GetUniformValue(const char* name, T& value) const
2265 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2266 program_it != mUniforms.end();
2269 const UniformIDMap& uniformIDs = program_it->second;
2271 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2272 if(uniform_it != uniformIDs.end())
2274 // found one matching uniform name, lets check the value...
2275 GLuint programId = program_it->first;
2276 GLint uniformId = uniform_it->second;
2278 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2279 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2285 template<typename T>
2286 inline bool CheckUniformValue(const char* name, const T& value) const
2288 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2289 program_it != mUniforms.end();
2292 const UniformIDMap& uniformIDs = program_it->second;
2294 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2295 if(uniform_it != uniformIDs.end())
2297 // found one matching uniform name, lets check the value...
2298 GLuint programId = program_it->first;
2299 GLint uniformId = uniform_it->second;
2301 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2302 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2304 // the value matches
2310 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2311 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2312 program_it != mUniforms.end();
2315 const UniformIDMap& uniformIDs = program_it->second;
2317 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2318 if(uniform_it != uniformIDs.end())
2320 // found one matching uniform name, lets check the value...
2321 GLuint programId = program_it->first;
2322 GLint uniformId = uniform_it->second;
2324 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2326 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2328 std::stringstream out;
2329 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2330 fprintf(stderr, "%s\n", out.str().c_str());
2337 template<typename T>
2338 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2340 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2341 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2344 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2346 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2347 program_it != mUniforms.end();
2350 const UniformIDMap& uniformIDs = program_it->second;
2352 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2353 if(uniform_it != uniformIDs.end())
2355 programId = program_it->first;
2356 uniformId = uniform_it->second;
2363 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2365 mCustomUniformData = customUniformData;
2368 inline GLuint GetLastShaderCompiled() const
2370 return mLastShaderCompiled;
2373 inline GLuint GetLastProgramCreated() const
2375 return mLastProgramIdUsed;
2378 inline GLbitfield GetLastClearMask() const
2380 return mLastClearBitMask;
2385 ATTRIB_UNKNOWN = -1,
2390 ATTRIB_BONE_WEIGHTS,
2391 ATTRIB_BONE_INDICES,
2395 struct ScissorParams
2411 // Methods to check scissor tests
2412 inline const ScissorParams& GetScissorParams() const
2414 return mScissorParams;
2417 struct ColorMaskParams
2433 inline bool GetProgramBinaryCalled() const
2435 return mGetProgramBinaryCalled;
2438 inline unsigned int GetClearCountCalled() const
2443 inline const ColorMaskParams& GetColorMaskParams() const
2445 return mColorMaskParams;
2448 typedef std::vector<size_t> BufferDataCalls;
2449 inline const BufferDataCalls& GetBufferDataCalls() const
2451 return mBufferDataCalls;
2453 inline void ResetBufferDataCalls()
2455 mBufferDataCalls.clear();
2458 typedef std::vector<size_t> BufferSubDataCalls;
2459 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2461 return mBufferSubDataCalls;
2463 inline void ResetBufferSubDataCalls()
2465 mBufferSubDataCalls.clear();
2469 GLuint mCurrentProgram;
2470 GLuint mCompileStatus;
2471 BufferDataCalls mBufferDataCalls;
2472 BufferSubDataCalls mBufferSubDataCalls;
2473 GLvoid* mMappedBuffer{nullptr};
2475 GLint mNumberOfActiveUniforms;
2476 GLenum mGetErrorResult;
2477 GLubyte* mGetStringResult;
2478 GLboolean mIsBufferResult;
2479 GLboolean mIsEnabledResult;
2480 GLboolean mIsFramebufferResult;
2481 GLboolean mIsProgramResult;
2482 GLboolean mIsRenderbufferResult;
2483 GLboolean mIsShaderResult;
2484 GLboolean mIsTextureResult;
2485 GLenum mActiveTextureUnit;
2486 GLenum mCheckFramebufferStatusResult;
2487 GLint mFramebufferStatus;
2488 GLenum mFramebufferDepthAttached;
2489 GLenum mFramebufferStencilAttached;
2490 GLuint mFramebufferColorAttachmentCount;
2491 GLuint mFrameBufferColorStatus;
2492 GLint mNumBinaryFormats;
2493 GLint mBinaryFormats;
2494 GLint mProgramBinaryLength;
2495 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2496 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2497 bool mGetProgramBinaryCalled;
2498 typedef std::map<GLuint, std::string> ShaderSourceMap;
2499 ShaderSourceMap mShaderSources;
2500 std::vector<std::string> mAttribLocs; // should be bound to shader
2501 GLuint mLastShaderCompiled;
2502 GLbitfield mLastClearBitMask;
2503 Vector4 mLastClearColor;
2504 unsigned int mClearCount;
2506 Vector4 mLastBlendColor;
2507 GLenum mLastBlendEquationRgb;
2508 GLenum mLastBlendEquationAlpha;
2509 GLenum mLastBlendFuncSrcRgb;
2510 GLenum mLastBlendFuncDstRgb;
2511 GLenum mLastBlendFuncSrcAlpha;
2512 GLenum mLastBlendFuncDstAlpha;
2514 GLboolean mLastDepthMask;
2516 // Data for manipulating the IDs returned by GenTextures
2517 GLuint mLastAutoTextureIdUsed;
2518 GLuint mNumGeneratedTextures;
2519 std::vector<GLuint> mNextTextureIds;
2520 std::vector<GLuint> mDeletedTextureIds;
2521 std::vector<GLuint> mBoundTextures;
2523 struct ActiveTextureType
2525 std::vector<GLuint> mBoundTextures;
2528 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2530 TraceCallStack mBufferTrace;
2531 TraceCallStack mCullFaceTrace;
2532 TraceCallStack mEnableDisableTrace;
2533 TraceCallStack mShaderTrace;
2534 TraceCallStack mTextureTrace;
2535 TraceCallStack mTexParameterTrace;
2536 TraceCallStack mDrawTrace;
2537 TraceCallStack mDepthFunctionTrace;
2538 TraceCallStack mStencilFunctionTrace;
2539 TraceCallStack mScissorTrace;
2540 TraceCallStack mSetUniformTrace;
2541 TraceCallStack mViewportTrace;
2543 // Shaders & Uniforms
2544 GLuint mLastShaderIdUsed;
2545 GLuint mLastProgramIdUsed{0u};
2546 GLuint mLastUniformIdUsed;
2547 typedef std::map<std::string, GLint> UniformIDMap;
2548 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2549 ProgramUniformMap mUniforms;
2551 std::vector<UniformData> mCustomUniformData{};
2553 template<typename T>
2554 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2557 typedef std::map<GLint, T> UniformValueMap;
2558 typedef std::map<GLuint, UniformValueMap> Map;
2560 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2567 typename Map::iterator it = Map::find(program);
2568 if(it == Map::end())
2570 // if its the first uniform for this program add it
2571 std::pair<typename Map::iterator, bool> result =
2572 Map::insert(typename Map::value_type(program, UniformValueMap()));
2576 UniformValueMap& uniforms = it->second;
2577 uniforms[uniform] = value;
2582 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2585 if(GetUniformValue(program, uniform, uniformValue))
2587 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2593 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2600 typename Map::const_iterator it = Map::find(program);
2601 if(it == Map::end())
2603 // Uniform values always initialised as 0
2608 const UniformValueMap& uniforms = it->second;
2609 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2610 if(it2 == uniforms.end())
2612 // Uniform values always initialised as 0
2616 value = it2->second;
2623 ProgramUniformValue<int> mProgramUniforms1i;
2624 ProgramUniformValue<float> mProgramUniforms1f;
2625 ProgramUniformValue<Vector2> mProgramUniforms2f;
2626 ProgramUniformValue<Vector3> mProgramUniforms3f;
2627 ProgramUniformValue<Vector4> mProgramUniforms4f;
2628 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2629 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2631 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2633 return mProgramUniforms1i;
2635 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2637 return mProgramUniforms1f;
2639 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2641 return mProgramUniforms2f;
2643 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2645 return mProgramUniforms3f;
2647 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2649 return mProgramUniforms4f;
2651 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2653 return mProgramUniformsMat4;
2655 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2657 return mProgramUniformsMat3;
2659 inline void SetVertexAttribArray(GLuint index, bool state)
2661 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2666 mVertexAttribArrayState[index] = state;
2667 mVertexAttribArrayChanged = true;
2670 ScissorParams mScissorParams;
2671 ColorMaskParams mColorMaskParams;
2675 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2681 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2687 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2689 return Vector2::ZERO;
2693 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2695 return Vector3::ZERO;
2699 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2701 return Vector4::ZERO;
2705 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2711 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2713 return Matrix3(Matrix());
2718 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2719 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2721 #endif // TEST_GL_ABSTRACTION_H