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;
624 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
626 mFramebufferStencilAttached = true;
627 mFramebufferDepthAttached = true;
631 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
634 mFramebufferStatus |= 4;
636 //We check 4 attachment colors
637 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
639 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
640 if((mFrameBufferColorStatus & mask) == 0)
642 mFrameBufferColorStatus |= mask;
643 ++mFramebufferColorAttachmentCount;
648 inline void FrontFace(GLenum mode) override
653 inline void GenBuffers(GLsizei n, GLuint* buffers) override
655 // avoids an assert in GpuBuffers
658 std::ostringstream o;
660 TraceCallStack::NamedParams namedParams;
661 namedParams["n"] << o.str();
662 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
665 inline void GenerateMipmap(GLenum target) override
667 std::stringstream out;
669 TraceCallStack::NamedParams namedParams;
670 namedParams["target"] << std::hex << target;
672 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
675 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
677 for(int i = 0; i < n; i++)
679 framebuffers[i] = i + 1;
682 //Add 001 bit, this function needs to be called the first one in the chain
683 mFramebufferStatus = 1;
686 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
688 for(int i = 0; i < n; i++)
690 renderbuffers[i] = i + 1;
695 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
696 * @param[in] ids A vector containing the next IDs to be generated
698 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
700 mNextTextureIds = ids;
703 inline const std::vector<GLuint>& GetNextTextureIds()
705 return mNextTextureIds;
708 inline void GenTextures(GLsizei count, GLuint* textures) override
710 for(int i = 0; i < count; ++i)
712 if(!mNextTextureIds.empty())
714 *(textures + i) = mNextTextureIds[0];
715 mNextTextureIds.erase(mNextTextureIds.begin());
719 *(textures + i) = ++mLastAutoTextureIdUsed;
721 mNumGeneratedTextures++;
724 TraceCallStack::NamedParams namedParams;
725 namedParams["count"] << count;
727 std::stringstream out;
728 for(int i = 0; i < count; i++)
735 std::ostringstream oss;
736 oss << "indices[" << i << "]";
737 namedParams[oss.str()] << textures[i];
740 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
743 inline GLuint GetLastGenTextureId()
745 return mLastAutoTextureIdUsed;
748 inline GLuint GetNumGeneratedTextures()
750 return mNumGeneratedTextures;
753 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
757 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
762 *length = snprintf(name, bufsize, "sTexture");
763 *type = GL_SAMPLER_2D;
767 *length = snprintf(name, bufsize, "sEffect");
768 *type = GL_SAMPLER_2D;
772 *length = snprintf(name, bufsize, "sGloss");
773 *type = GL_SAMPLER_2D;
781 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
785 inline int GetAttribLocation(GLuint program, const char* name) override
787 std::string check(name);
788 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
789 if(iter == mAttribLocs.end())
791 return iter - mAttribLocs.begin();
794 inline void GetBooleanv(GLenum pname, GLboolean* params) override
798 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
802 inline GLenum GetError(void) override
804 return mGetErrorResult;
807 inline void GetFloatv(GLenum pname, GLfloat* params) override
811 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
815 inline void GetIntegerv(GLenum pname, GLint* params) override
819 case GL_MAX_TEXTURE_SIZE:
822 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
825 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
826 *params = mNumBinaryFormats;
828 case GL_PROGRAM_BINARY_FORMATS_OES:
829 *params = mBinaryFormats;
834 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
839 *params = mLinkStatus;
841 case GL_PROGRAM_BINARY_LENGTH_OES:
842 *params = mProgramBinaryLength;
844 case GL_ACTIVE_UNIFORMS:
845 *params = mNumberOfActiveUniforms;
847 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
850 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
856 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
860 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
864 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
868 case GL_COMPILE_STATUS:
869 *params = mCompileStatus;
874 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
878 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
882 inline const GLubyte* GetString(GLenum name) override
884 return mGetStringResult;
887 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
891 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
895 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
899 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
903 inline GLint GetUniformLocation(GLuint program, const char* name) override
905 ProgramUniformMap::iterator it = mUniforms.find(program);
906 if(it == mUniforms.end())
908 // Not a valid program ID
909 mGetErrorResult = GL_INVALID_OPERATION;
913 UniformIDMap& uniformIDs = it->second;
914 UniformIDMap::iterator it2 = uniformIDs.find(name);
915 if(it2 == uniformIDs.end())
917 // Uniform not found, so add it...
918 uniformIDs[name] = mLastUniformIdUsed++;
919 return mLastUniformIdUsed;
925 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
929 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
933 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
937 inline void Hint(GLenum target, GLenum mode) override
941 inline GLboolean IsBuffer(GLuint buffer) override
943 return mIsBufferResult;
946 inline GLboolean IsEnabled(GLenum cap) override
948 return mIsEnabledResult;
951 inline GLboolean IsFramebuffer(GLuint framebuffer) override
953 return mIsFramebufferResult;
956 inline GLboolean IsProgram(GLuint program) override
958 return mIsProgramResult;
961 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
963 return mIsRenderbufferResult;
966 inline GLboolean IsShader(GLuint shader) override
968 return mIsShaderResult;
971 inline GLboolean IsTexture(GLuint texture) override
973 return mIsTextureResult;
976 inline void LineWidth(GLfloat width) override
980 inline void LinkProgram(GLuint program) override
982 std::stringstream out;
985 TraceCallStack::NamedParams namedParams;
986 namedParams["program"] << program;
987 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
989 mNumberOfActiveUniforms = 3;
991 GetUniformLocation(program, "uRendererColor");
992 GetUniformLocation(program, "uCustom");
993 GetUniformLocation(program, "uCustom3");
994 GetUniformLocation(program, "uFadeColor");
995 GetUniformLocation(program, "uUniform1");
996 GetUniformLocation(program, "uUniform2");
997 GetUniformLocation(program, "uUniform3");
998 GetUniformLocation(program, "uFadeProgress");
999 GetUniformLocation(program, "uANormalMatrix");
1000 GetUniformLocation(program, "sEffect");
1001 GetUniformLocation(program, "sTexture");
1002 GetUniformLocation(program, "sTextureRect");
1003 GetUniformLocation(program, "sGloss");
1004 GetUniformLocation(program, "uColor");
1005 GetUniformLocation(program, "uModelMatrix");
1006 GetUniformLocation(program, "uModelView");
1007 GetUniformLocation(program, "uMvpMatrix");
1008 GetUniformLocation(program, "uNormalMatrix");
1009 GetUniformLocation(program, "uProjection");
1010 GetUniformLocation(program, "uSize");
1011 GetUniformLocation(program, "uViewMatrix");
1012 GetUniformLocation(program, "uLightCameraProjectionMatrix");
1013 GetUniformLocation(program, "uLightCameraViewMatrix");
1015 for(const auto& uniform : mCustomUniformData)
1017 GetUniformLocation(program, uniform.name.c_str());
1021 inline void PixelStorei(GLenum pname, GLint param) override
1025 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1029 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1033 inline void ReleaseShaderCompiler(void) override
1037 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1041 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1045 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1047 mScissorParams.x = x;
1048 mScissorParams.y = y;
1049 mScissorParams.width = width;
1050 mScissorParams.height = height;
1052 std::stringstream out;
1053 out << x << ", " << y << ", " << width << ", " << height;
1054 TraceCallStack::NamedParams namedParams;
1055 namedParams["x"] << x;
1056 namedParams["y"] << y;
1057 namedParams["width"] << width;
1058 namedParams["height"] << height;
1059 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1062 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1066 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1068 std::string stringBuilder;
1069 for(int i = 0; i < count; ++i)
1071 stringBuilder += string[i];
1073 mShaderSources[shader] = stringBuilder;
1074 mLastShaderCompiled = shader;
1077 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1079 const std::string shaderSource = mShaderSources[shader];
1080 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1081 if(shaderSourceLength < bufsize)
1083 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1084 *length = shaderSourceLength;
1088 *length = bufsize - 1;
1089 strncpy(source, shaderSource.c_str(), *length);
1090 source[*length] = 0x0;
1094 inline std::string GetShaderSource(GLuint shader)
1096 return mShaderSources[shader];
1099 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1101 std::stringstream out;
1102 out << func << ", " << ref << ", " << mask;
1104 TraceCallStack::NamedParams namedParams;
1105 namedParams["func"] << std::hex << func;
1106 namedParams["ref"] << ref;
1107 namedParams["mask"] << mask;
1109 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1112 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1114 std::stringstream out;
1115 out << face << ", " << func << ", " << ref << ", " << mask;
1117 TraceCallStack::NamedParams namedParams;
1118 namedParams["face"] << std::hex << face;
1119 namedParams["func"] << std::hex << func;
1120 namedParams["ref"] << ref;
1121 namedParams["mask"] << mask;
1123 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1126 inline void StencilMask(GLuint mask) override
1128 std::stringstream out;
1131 TraceCallStack::NamedParams namedParams;
1132 namedParams["mask"] << mask;
1134 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1137 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1139 std::stringstream out;
1140 out << face << ", " << mask;
1142 TraceCallStack::NamedParams namedParams;
1143 namedParams["face"] << std::hex << face;
1144 namedParams["mask"] << mask;
1146 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1149 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1151 std::stringstream out;
1152 out << fail << ", " << zfail << ", " << zpass;
1154 TraceCallStack::NamedParams namedParams;
1155 namedParams["fail"] << std::hex << fail;
1156 namedParams["zfail"] << std::hex << zfail;
1157 namedParams["zpass"] << std::hex << zpass;
1159 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1162 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1164 std::stringstream out;
1165 out << face << ", " << fail << ", " << zfail << "," << zpass;
1167 TraceCallStack::NamedParams namedParams;
1168 namedParams["face"] << std::hex << face;
1169 namedParams["fail"] << std::hex << fail;
1170 namedParams["zfail"] << std::hex << zfail;
1171 namedParams["zpass"] << std::hex << zpass;
1173 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1176 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1178 std::stringstream out;
1179 out << target << ", " << level << ", " << width << ", " << height;
1181 TraceCallStack::NamedParams namedParams;
1182 namedParams["target"] << std::hex << target;
1183 namedParams["level"] << level;
1184 namedParams["internalformat"] << internalformat;
1185 namedParams["width"] << width;
1186 namedParams["height"] << height;
1187 namedParams["border"] << border;
1188 namedParams["format"] << std::hex << format;
1189 namedParams["type"] << std::hex << type;
1191 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1194 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1196 std::stringstream out;
1197 out << target << ", " << pname << ", " << param;
1199 TraceCallStack::NamedParams namedParams;
1200 namedParams["target"] << std::hex << target;
1201 namedParams["pname"] << std::hex << pname;
1202 namedParams["param"] << param;
1204 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1207 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1209 std::stringstream out;
1210 out << target << ", " << pname << ", " << params[0];
1212 TraceCallStack::NamedParams namedParams;
1213 namedParams["target"] << std::hex << target;
1214 namedParams["pname"] << std::hex << pname;
1215 namedParams["params[0]"] << params[0];
1217 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1220 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1222 std::stringstream out;
1223 out << std::hex << target << ", " << pname << ", " << param;
1224 std::string params = out.str();
1226 TraceCallStack::NamedParams namedParams;
1227 namedParams["target"] << std::hex << target;
1228 namedParams["pname"] << std::hex << pname;
1229 namedParams["param"] << param;
1230 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1233 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1235 std::stringstream out;
1236 out << target << ", " << pname << ", " << params[0];
1237 TraceCallStack::NamedParams namedParams;
1238 namedParams["target"] << std::hex << target;
1239 namedParams["pname"] << std::hex << pname;
1240 namedParams["params[0]"] << params[0];
1241 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1244 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1246 std::stringstream out;
1247 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1249 TraceCallStack::NamedParams namedParams;
1250 namedParams["target"] << std::hex << target;
1251 namedParams["level"] << level;
1252 namedParams["xoffset"] << xoffset;
1253 namedParams["yoffset"] << yoffset;
1254 namedParams["width"] << width;
1255 namedParams["height"] << height;
1256 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1259 inline void Uniform1f(GLint location, GLfloat value) override
1261 std::string params = std::to_string(value);
1262 AddUniformCallToTraceStack(location, params);
1264 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1266 mGetErrorResult = GL_INVALID_OPERATION;
1270 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1273 for(int i = 0; i < count; ++i)
1275 params = params + std::to_string(v[i]) + ",";
1278 AddUniformCallToTraceStack(location, params);
1280 for(int i = 0; i < count; ++i)
1282 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1284 mGetErrorResult = GL_INVALID_OPERATION;
1290 inline void Uniform1i(GLint location, GLint x) override
1292 std::string params = std::to_string(x);
1294 AddUniformCallToTraceStack(location, params);
1296 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1298 mGetErrorResult = GL_INVALID_OPERATION;
1302 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1304 std::ostringstream out;
1305 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1306 AddUniformCallToTraceStack(location, out.str());
1308 for(int i = 0; i < count; ++i)
1310 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1314 mGetErrorResult = GL_INVALID_OPERATION;
1320 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1322 std::string params = std::to_string(x) + "," + std::to_string(y);
1323 AddUniformCallToTraceStack(location, params);
1325 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1329 mGetErrorResult = GL_INVALID_OPERATION;
1333 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1335 std::ostringstream out;
1336 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1337 AddUniformCallToTraceStack(location, out.str());
1339 for(int i = 0; i < count; ++i)
1341 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1343 Vector2(v[2 * i], v[2 * i + 1])))
1345 mGetErrorResult = GL_INVALID_OPERATION;
1351 inline void Uniform2i(GLint location, GLint x, GLint y) override
1353 std::string params = std::to_string(x) + "," + std::to_string(y);
1354 AddUniformCallToTraceStack(location, params);
1357 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1359 std::ostringstream out;
1360 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1361 AddUniformCallToTraceStack(location, out.str());
1364 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1366 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1367 AddUniformCallToTraceStack(location, params);
1369 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1373 mGetErrorResult = GL_INVALID_OPERATION;
1377 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1379 std::ostringstream out;
1380 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1381 AddUniformCallToTraceStack(location, out.str());
1383 for(int i = 0; i < count; ++i)
1385 if(!mProgramUniforms3f.SetUniformValue(
1388 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1390 mGetErrorResult = GL_INVALID_OPERATION;
1396 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1398 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1399 AddUniformCallToTraceStack(location, params);
1402 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1404 std::ostringstream out;
1405 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1406 AddUniformCallToTraceStack(location, out.str());
1409 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1411 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1412 AddUniformCallToTraceStack(location, params);
1414 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1416 Vector4(x, y, z, w)))
1418 mGetErrorResult = GL_INVALID_OPERATION;
1422 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1424 std::ostringstream out;
1425 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1426 AddUniformCallToTraceStack(location, out.str());
1428 for(int i = 0; i < count; ++i)
1430 if(!mProgramUniforms4f.SetUniformValue(
1433 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1435 mGetErrorResult = GL_INVALID_OPERATION;
1441 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1443 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1444 AddUniformCallToTraceStack(location, params);
1447 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1449 std::ostringstream out;
1450 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1451 AddUniformCallToTraceStack(location, out.str());
1454 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1456 std::ostringstream out;
1457 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1458 AddUniformCallToTraceStack(location, out.str());
1461 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1463 std::ostringstream out;
1464 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1465 AddUniformCallToTraceStack(location, out.str());
1467 for(int i = 0; i < count; ++i)
1469 if(!mProgramUniformsMat3.SetUniformValue(
1472 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1474 mGetErrorResult = GL_INVALID_OPERATION;
1480 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1482 std::ostringstream out;
1483 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1484 AddUniformCallToTraceStack(location, out.str());
1486 for(int i = 0; i < count; ++i)
1488 if(!mProgramUniformsMat4.SetUniformValue(
1493 mGetErrorResult = GL_INVALID_OPERATION;
1499 inline void UseProgram(GLuint program) override
1501 mCurrentProgram = program;
1504 inline void ValidateProgram(GLuint program) override
1508 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1512 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1516 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1520 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1524 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1528 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1532 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1536 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1540 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1542 TraceCallStack::NamedParams namedParams;
1543 namedParams["index"] << index;
1544 namedParams["size"] << size;
1545 namedParams["type"] << std::hex << type;
1546 namedParams["normalized"] << (normalized ? "T" : "F");
1547 namedParams["stride"] << stride;
1548 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1550 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1553 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1555 std::string commaString(", ");
1556 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1558 mViewportTrace.PushCall("Viewport", params);
1563 inline void ReadBuffer(GLenum mode) override
1567 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1571 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
1575 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
1579 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1583 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1587 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
1591 inline void GenQueries(GLsizei n, GLuint* ids) override
1595 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1599 inline GLboolean IsQuery(GLuint id) override
1604 inline void BeginQuery(GLenum target, GLuint id) override
1608 inline void EndQuery(GLenum target) override
1612 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1616 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1620 inline GLboolean UnmapBuffer(GLenum target) override
1624 free(mMappedBuffer);
1625 mMappedBuffer = nullptr;
1627 return true; // false indicates corruption, nothing else.
1630 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1634 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1638 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1642 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1646 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1650 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1654 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1658 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1662 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1666 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1670 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1674 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1676 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1677 return mMappedBuffer;
1680 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1684 inline void BindVertexArray(GLuint array) override
1688 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1692 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1696 inline GLboolean IsVertexArray(GLuint array) override
1701 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1705 inline void BeginTransformFeedback(GLenum primitiveMode) override
1709 inline void EndTransformFeedback(void) override
1713 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1717 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1721 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1725 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1729 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1733 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1737 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1741 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1745 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1749 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1753 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1757 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1761 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1766 inline void Uniform1ui(GLint location, GLuint v0) override
1770 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1774 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1778 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1782 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1786 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1790 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1794 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1798 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1802 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1806 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1810 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1814 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1819 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1823 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1827 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1831 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1833 return GL_INVALID_INDEX;
1836 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1840 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1844 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1848 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1852 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1856 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1861 inline GLboolean IsSync(GLsync sync) override
1866 inline void DeleteSync(GLsync sync) override
1870 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1875 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1879 inline void GetInteger64v(GLenum pname, GLint64* params) override
1883 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1887 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1891 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1895 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1899 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1903 inline GLboolean IsSampler(GLuint sampler) override
1908 inline void BindSampler(GLuint unit, GLuint sampler) override
1912 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1916 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1920 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1924 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1928 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1932 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1936 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1940 inline void BindTransformFeedback(GLenum target, GLuint id) override
1944 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1948 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1952 inline GLboolean IsTransformFeedback(GLuint id) override
1957 inline void PauseTransformFeedback(void) override
1961 inline void ResumeTransformFeedback(void) override
1965 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1967 mGetProgramBinaryCalled = true;
1970 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1974 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1978 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1982 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1986 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1990 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1994 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1998 inline void BlendBarrier(void)
2003 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2005 std::string name = "<not found>";
2006 bool matched = false;
2008 UniformIDMap& map = mUniforms[mCurrentProgram];
2009 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2011 if(it->second == location)
2021 mSetUniformTrace.PushCall(name, value);
2025 public: // TEST FUNCTIONS
2026 inline void SetCompileStatus(GLuint value)
2028 mCompileStatus = value;
2030 inline void SetLinkStatus(GLuint value)
2032 mLinkStatus = value;
2034 inline void SetAttribLocations(std::vector<std::string> locs)
2038 inline void SetGetErrorResult(GLenum result)
2040 mGetErrorResult = result;
2042 inline void SetGetStringResult(GLubyte* result)
2044 mGetStringResult = result;
2046 inline void SetIsBufferResult(GLboolean result)
2048 mIsBufferResult = result;
2050 inline void SetIsEnabledResult(GLboolean result)
2052 mIsEnabledResult = result;
2054 inline void SetIsFramebufferResult(GLboolean result)
2056 mIsFramebufferResult = result;
2058 inline void SetIsProgramResult(GLboolean result)
2060 mIsProgramResult = result;
2062 inline void SetIsRenderbufferResult(GLboolean result)
2064 mIsRenderbufferResult = result;
2066 inline void SetIsShaderResult(GLboolean result)
2068 mIsShaderResult = result;
2070 inline void SetIsTextureResult(GLboolean result)
2072 mIsTextureResult = result;
2074 inline void SetCheckFramebufferStatusResult(GLenum result)
2076 mCheckFramebufferStatusResult = result;
2078 inline void SetNumBinaryFormats(GLint numFormats)
2080 mNumBinaryFormats = numFormats;
2082 inline void SetBinaryFormats(GLint binaryFormats)
2084 mBinaryFormats = binaryFormats;
2086 inline void SetProgramBinaryLength(GLint length)
2088 mProgramBinaryLength = length;
2091 inline bool GetVertexAttribArrayState(GLuint index)
2093 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2098 return mVertexAttribArrayState[index];
2100 inline void ClearVertexAttribArrayChanged()
2102 mVertexAttribArrayChanged = false;
2104 inline bool GetVertexAttribArrayChanged()
2106 return mVertexAttribArrayChanged;
2109 //Methods for CullFace verification
2110 inline void EnableCullFaceCallTrace(bool enable)
2112 mCullFaceTrace.Enable(enable);
2114 inline void ResetCullFaceCallStack()
2116 mCullFaceTrace.Reset();
2118 inline TraceCallStack& GetCullFaceTrace()
2120 return mCullFaceTrace;
2123 //Methods for Enable/Disable call verification
2124 inline void EnableEnableDisableCallTrace(bool enable)
2126 mEnableDisableTrace.Enable(enable);
2128 inline void ResetEnableDisableCallStack()
2130 mEnableDisableTrace.Reset();
2132 inline TraceCallStack& GetEnableDisableTrace()
2134 return mEnableDisableTrace;
2137 //Methods for Shader verification
2138 inline void EnableShaderCallTrace(bool enable)
2140 mShaderTrace.Enable(enable);
2142 inline void ResetShaderCallStack()
2144 mShaderTrace.Reset();
2146 inline TraceCallStack& GetShaderTrace()
2148 return mShaderTrace;
2151 //Methods for Texture verification
2152 inline void EnableTextureCallTrace(bool enable)
2154 mTextureTrace.Enable(enable);
2156 inline void ResetTextureCallStack()
2158 mTextureTrace.Reset();
2160 inline TraceCallStack& GetTextureTrace()
2162 return mTextureTrace;
2165 //Methods for Texture verification
2166 inline void EnableTexParameterCallTrace(bool enable)
2168 mTexParameterTrace.Enable(enable);
2170 inline void ResetTexParameterCallStack()
2172 mTexParameterTrace.Reset();
2174 inline TraceCallStack& GetTexParameterTrace()
2176 return mTexParameterTrace;
2179 //Methods for Draw verification
2180 inline void EnableDrawCallTrace(bool enable)
2182 mDrawTrace.Enable(enable);
2184 inline void ResetDrawCallStack()
2188 inline TraceCallStack& GetDrawTrace()
2193 //Methods for Depth function verification
2194 inline void EnableDepthFunctionCallTrace(bool enable)
2196 mDepthFunctionTrace.Enable(enable);
2198 inline void ResetDepthFunctionCallStack()
2200 mDepthFunctionTrace.Reset();
2202 inline TraceCallStack& GetDepthFunctionTrace()
2204 return mDepthFunctionTrace;
2207 //Methods for Stencil function verification
2208 inline void EnableStencilFunctionCallTrace(bool enable)
2210 mStencilFunctionTrace.Enable(enable);
2212 inline void ResetStencilFunctionCallStack()
2214 mStencilFunctionTrace.Reset();
2216 inline TraceCallStack& GetStencilFunctionTrace()
2218 return mStencilFunctionTrace;
2221 //Methods for Scissor verification
2222 inline void EnableScissorCallTrace(bool enable)
2224 mScissorTrace.Enable(enable);
2226 inline void ResetScissorCallStack()
2228 mScissorTrace.Reset();
2230 inline TraceCallStack& GetScissorTrace()
2232 return mScissorTrace;
2235 //Methods for Uniform function verification
2236 inline void EnableSetUniformCallTrace(bool enable)
2238 mSetUniformTrace.Enable(enable);
2240 inline void ResetSetUniformCallStack()
2242 mSetUniformTrace.Reset();
2244 inline TraceCallStack& GetSetUniformTrace()
2246 return mSetUniformTrace;
2249 //Methods for Viewport verification
2250 inline void EnableViewportCallTrace(bool enable)
2252 mViewportTrace.Enable(enable);
2254 inline void ResetViewportCallStack()
2256 mViewportTrace.Reset();
2258 inline TraceCallStack& GetViewportTrace()
2260 return mViewportTrace;
2262 inline TraceCallStack& GetBufferTrace()
2264 return mBufferTrace;
2267 template<typename T>
2268 inline bool GetUniformValue(const char* name, T& value) const
2270 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2271 program_it != mUniforms.end();
2274 const UniformIDMap& uniformIDs = program_it->second;
2276 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2277 if(uniform_it != uniformIDs.end())
2279 // found one matching uniform name, lets check the value...
2280 GLuint programId = program_it->first;
2281 GLint uniformId = uniform_it->second;
2283 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2284 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2290 template<typename T>
2291 inline bool CheckUniformValue(const char* name, const T& value) const
2293 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2294 program_it != mUniforms.end();
2297 const UniformIDMap& uniformIDs = program_it->second;
2299 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2300 if(uniform_it != uniformIDs.end())
2302 // found one matching uniform name, lets check the value...
2303 GLuint programId = program_it->first;
2304 GLint uniformId = uniform_it->second;
2306 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2307 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2309 // the value matches
2315 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2316 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2317 program_it != mUniforms.end();
2320 const UniformIDMap& uniformIDs = program_it->second;
2322 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2323 if(uniform_it != uniformIDs.end())
2325 // found one matching uniform name, lets check the value...
2326 GLuint programId = program_it->first;
2327 GLint uniformId = uniform_it->second;
2329 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2331 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2333 std::stringstream out;
2334 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2335 fprintf(stderr, "%s\n", out.str().c_str());
2342 template<typename T>
2343 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2345 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2346 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2349 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2351 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2352 program_it != mUniforms.end();
2355 const UniformIDMap& uniformIDs = program_it->second;
2357 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2358 if(uniform_it != uniformIDs.end())
2360 programId = program_it->first;
2361 uniformId = uniform_it->second;
2368 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2370 mCustomUniformData = customUniformData;
2373 inline GLuint GetLastShaderCompiled() const
2375 return mLastShaderCompiled;
2378 inline GLuint GetLastProgramCreated() const
2380 return mLastProgramIdUsed;
2383 inline GLbitfield GetLastClearMask() const
2385 return mLastClearBitMask;
2390 ATTRIB_UNKNOWN = -1,
2395 ATTRIB_BONE_WEIGHTS,
2396 ATTRIB_BONE_INDICES,
2400 struct ScissorParams
2416 // Methods to check scissor tests
2417 inline const ScissorParams& GetScissorParams() const
2419 return mScissorParams;
2422 struct ColorMaskParams
2438 inline bool GetProgramBinaryCalled() const
2440 return mGetProgramBinaryCalled;
2443 inline unsigned int GetClearCountCalled() const
2448 inline const ColorMaskParams& GetColorMaskParams() const
2450 return mColorMaskParams;
2453 typedef std::vector<size_t> BufferDataCalls;
2454 inline const BufferDataCalls& GetBufferDataCalls() const
2456 return mBufferDataCalls;
2458 inline void ResetBufferDataCalls()
2460 mBufferDataCalls.clear();
2463 typedef std::vector<size_t> BufferSubDataCalls;
2464 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2466 return mBufferSubDataCalls;
2468 inline void ResetBufferSubDataCalls()
2470 mBufferSubDataCalls.clear();
2474 GLuint mCurrentProgram;
2475 GLuint mCompileStatus;
2476 BufferDataCalls mBufferDataCalls;
2477 BufferSubDataCalls mBufferSubDataCalls;
2478 GLvoid* mMappedBuffer{nullptr};
2480 GLint mNumberOfActiveUniforms;
2481 GLenum mGetErrorResult;
2482 GLubyte* mGetStringResult;
2483 GLboolean mIsBufferResult;
2484 GLboolean mIsEnabledResult;
2485 GLboolean mIsFramebufferResult;
2486 GLboolean mIsProgramResult;
2487 GLboolean mIsRenderbufferResult;
2488 GLboolean mIsShaderResult;
2489 GLboolean mIsTextureResult;
2490 GLenum mActiveTextureUnit;
2491 GLenum mCheckFramebufferStatusResult;
2492 GLint mFramebufferStatus;
2493 GLenum mFramebufferDepthAttached;
2494 GLenum mFramebufferStencilAttached;
2495 GLuint mFramebufferColorAttachmentCount;
2496 GLuint mFrameBufferColorStatus;
2497 GLint mNumBinaryFormats;
2498 GLint mBinaryFormats;
2499 GLint mProgramBinaryLength;
2500 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2501 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2502 bool mGetProgramBinaryCalled;
2503 typedef std::map<GLuint, std::string> ShaderSourceMap;
2504 ShaderSourceMap mShaderSources;
2505 std::vector<std::string> mAttribLocs; // should be bound to shader
2506 GLuint mLastShaderCompiled;
2507 GLbitfield mLastClearBitMask;
2508 Vector4 mLastClearColor;
2509 unsigned int mClearCount;
2511 Vector4 mLastBlendColor;
2512 GLenum mLastBlendEquationRgb;
2513 GLenum mLastBlendEquationAlpha;
2514 GLenum mLastBlendFuncSrcRgb;
2515 GLenum mLastBlendFuncDstRgb;
2516 GLenum mLastBlendFuncSrcAlpha;
2517 GLenum mLastBlendFuncDstAlpha;
2519 GLboolean mLastDepthMask;
2521 // Data for manipulating the IDs returned by GenTextures
2522 GLuint mLastAutoTextureIdUsed;
2523 GLuint mNumGeneratedTextures;
2524 std::vector<GLuint> mNextTextureIds;
2525 std::vector<GLuint> mDeletedTextureIds;
2526 std::vector<GLuint> mBoundTextures;
2528 struct ActiveTextureType
2530 std::vector<GLuint> mBoundTextures;
2533 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2535 TraceCallStack mBufferTrace;
2536 TraceCallStack mCullFaceTrace;
2537 TraceCallStack mEnableDisableTrace;
2538 TraceCallStack mShaderTrace;
2539 TraceCallStack mTextureTrace;
2540 TraceCallStack mTexParameterTrace;
2541 TraceCallStack mDrawTrace;
2542 TraceCallStack mDepthFunctionTrace;
2543 TraceCallStack mStencilFunctionTrace;
2544 TraceCallStack mScissorTrace;
2545 TraceCallStack mSetUniformTrace;
2546 TraceCallStack mViewportTrace;
2548 // Shaders & Uniforms
2549 GLuint mLastShaderIdUsed;
2550 GLuint mLastProgramIdUsed{0u};
2551 GLuint mLastUniformIdUsed;
2552 typedef std::map<std::string, GLint> UniformIDMap;
2553 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2554 ProgramUniformMap mUniforms;
2556 std::vector<UniformData> mCustomUniformData{};
2558 template<typename T>
2559 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2562 typedef std::map<GLint, T> UniformValueMap;
2563 typedef std::map<GLuint, UniformValueMap> Map;
2565 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2572 typename Map::iterator it = Map::find(program);
2573 if(it == Map::end())
2575 // if its the first uniform for this program add it
2576 std::pair<typename Map::iterator, bool> result =
2577 Map::insert(typename Map::value_type(program, UniformValueMap()));
2581 UniformValueMap& uniforms = it->second;
2582 uniforms[uniform] = value;
2587 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2590 if(GetUniformValue(program, uniform, uniformValue))
2592 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2598 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2605 typename Map::const_iterator it = Map::find(program);
2606 if(it == Map::end())
2608 // Uniform values always initialised as 0
2613 const UniformValueMap& uniforms = it->second;
2614 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2615 if(it2 == uniforms.end())
2617 // Uniform values always initialised as 0
2621 value = it2->second;
2628 ProgramUniformValue<int> mProgramUniforms1i;
2629 ProgramUniformValue<float> mProgramUniforms1f;
2630 ProgramUniformValue<Vector2> mProgramUniforms2f;
2631 ProgramUniformValue<Vector3> mProgramUniforms3f;
2632 ProgramUniformValue<Vector4> mProgramUniforms4f;
2633 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2634 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2636 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2638 return mProgramUniforms1i;
2640 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2642 return mProgramUniforms1f;
2644 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2646 return mProgramUniforms2f;
2648 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2650 return mProgramUniforms3f;
2652 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2654 return mProgramUniforms4f;
2656 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2658 return mProgramUniformsMat4;
2660 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2662 return mProgramUniformsMat3;
2664 inline void SetVertexAttribArray(GLuint index, bool state)
2666 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2671 mVertexAttribArrayState[index] = state;
2672 mVertexAttribArrayChanged = true;
2675 ScissorParams mScissorParams;
2676 ColorMaskParams mColorMaskParams;
2680 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2686 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2692 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2694 return Vector2::ZERO;
2698 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2700 return Vector3::ZERO;
2704 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2706 return Vector4::ZERO;
2710 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2716 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2718 return Matrix3(Matrix());
2723 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2724 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2726 #endif // TEST_GL_ABSTRACTION_H