1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2022 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)
59 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
62 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
65 ~TestGlAbstraction() override;
68 void PreRender() override;
69 void PostRender() override;
71 bool IsSurfacelessContextSupported() const override;
73 bool IsAdvancedBlendEquationSupported() override;
75 bool IsMultisampledRenderToTextureSupported() override;
77 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
79 std::string GetShaderVersionPrefix();
81 std::string GetVertexShaderPrefix();
83 std::string GetFragmentShaderPrefix();
85 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
89 inline void ActiveTexture(GLenum textureUnit) override
91 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
94 inline GLenum GetActiveTextureUnit() const
96 return mActiveTextureUnit + GL_TEXTURE0;
99 inline void AttachShader(GLuint program, GLuint shader) override
101 std::stringstream out;
102 out << program << ", " << shader;
104 TraceCallStack::NamedParams namedParams;
105 namedParams["program"] << program;
106 namedParams["shader"] << shader;
107 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
110 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
114 inline void BindBuffer(GLenum target, GLuint buffer) override
116 std::ostringstream o;
117 o << std::hex << target << ", " << buffer;
118 TraceCallStack::NamedParams namedParams;
119 namedParams["target"] << target;
120 namedParams["buffer"] << buffer;
121 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
124 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
127 mFramebufferStatus |= 2;
130 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
135 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
136 * @return A vector containing the IDs that were bound.
138 inline const std::vector<GLuint>& GetBoundTextures() const
140 return mBoundTextures;
144 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
145 * @param[in] activeTextureUnit The specific active texture unit.
146 * @return A vector containing the IDs that were bound.
148 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
150 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
154 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
156 inline void ClearBoundTextures()
158 mBoundTextures.clear();
160 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
162 mActiveTextures[i].mBoundTextures.clear();
166 inline void BindTexture(GLenum target, GLuint texture) override
168 // Record the bound textures for future checks
171 mBoundTextures.push_back(texture);
173 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
175 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
179 std::stringstream out;
180 out << std::hex << target << ", " << std::dec << texture;
182 TraceCallStack::NamedParams namedParams;
183 namedParams["target"] << std::hex << target;
184 namedParams["texture"] << texture;
186 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
189 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
191 mLastBlendColor.r = red;
192 mLastBlendColor.g = green;
193 mLastBlendColor.b = blue;
194 mLastBlendColor.a = alpha;
197 inline const Vector4& GetLastBlendColor() const
199 return mLastBlendColor;
202 inline void BlendEquation(GLenum mode) override
204 mLastBlendEquationRgb = mode;
205 mLastBlendEquationAlpha = mode;
208 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
210 mLastBlendEquationRgb = modeRgb;
211 mLastBlendEquationAlpha = modeAlpha;
214 inline GLenum GetLastBlendEquationRgb() const
216 return mLastBlendEquationRgb;
219 inline GLenum GetLastBlendEquationAlpha() const
221 return mLastBlendEquationAlpha;
224 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
226 mLastBlendFuncSrcRgb = sfactor;
227 mLastBlendFuncDstRgb = dfactor;
228 mLastBlendFuncSrcAlpha = sfactor;
229 mLastBlendFuncDstAlpha = dfactor;
232 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
234 mLastBlendFuncSrcRgb = srcRGB;
235 mLastBlendFuncDstRgb = dstRGB;
236 mLastBlendFuncSrcAlpha = srcAlpha;
237 mLastBlendFuncDstAlpha = dstAlpha;
240 inline GLenum GetLastBlendFuncSrcRgb() const
242 return mLastBlendFuncSrcRgb;
245 inline GLenum GetLastBlendFuncDstRgb() const
247 return mLastBlendFuncDstRgb;
250 inline GLenum GetLastBlendFuncSrcAlpha() const
252 return mLastBlendFuncSrcAlpha;
255 inline GLenum GetLastBlendFuncDstAlpha() const
257 return mLastBlendFuncDstAlpha;
260 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
262 std::ostringstream o;
263 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
264 TraceCallStack::NamedParams namedParams;
265 namedParams["target"] << std::hex << target;
266 namedParams["size"] << size;
267 namedParams["usage"] << usage;
269 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
271 mBufferDataCalls.push_back(size);
274 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
276 std::ostringstream o;
277 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
278 TraceCallStack::NamedParams namedParams;
279 namedParams["target"] << std::hex << target;
280 namedParams["offset"] << offset;
281 namedParams["size"] << size;
282 mBufferTrace.PushCall("BufferSubData", o.str());
284 mBufferSubDataCalls.push_back(size);
287 inline GLenum CheckFramebufferStatus(GLenum target) override
289 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
290 //Framebuffer texture have been called
291 if(mFramebufferStatus == 7)
293 return GL_FRAMEBUFFER_COMPLETE;
296 return mCheckFramebufferStatusResult;
299 inline GLuint CheckFramebufferColorAttachmentCount()
301 return mFramebufferColorAttachmentCount;
304 inline GLuint CheckFramebufferDepthAttachmentCount()
306 return mFramebufferDepthAttachmentCount;
309 inline GLuint CheckFramebufferStencilAttachmentCount()
311 return mFramebufferStencilAttachmentCount;
314 inline GLuint CheckFramebufferDepthStencilAttachmentCount()
316 return mFramebufferDepthStencilAttachmentCount;
319 inline GLenum CheckFramebufferDepthAttachment()
321 return mFramebufferDepthAttached;
324 inline GLenum CheckFramebufferStencilAttachment()
326 return mFramebufferStencilAttached;
329 inline GLenum CheckFramebufferDepthStencilAttachment()
331 return mFramebufferDepthStencilAttached;
334 inline void Clear(GLbitfield mask) override
337 mLastClearBitMask = mask;
340 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
342 mLastClearColor.r = red;
343 mLastClearColor.g = green;
344 mLastClearColor.b = blue;
345 mLastClearColor.a = alpha;
348 inline const Vector4& GetLastClearColor() const
350 return mLastClearColor;
353 inline void ClearDepthf(GLclampf depth) override
357 inline void ClearStencil(GLint s) override
359 std::stringstream out;
362 TraceCallStack::NamedParams namedParams;
363 namedParams["s"] << s;
365 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
368 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
370 mColorMaskParams.red = red;
371 mColorMaskParams.green = green;
372 mColorMaskParams.blue = blue;
373 mColorMaskParams.alpha = alpha;
376 inline void CompileShader(GLuint shader) override
378 std::stringstream out;
380 TraceCallStack::NamedParams namedParams;
381 namedParams["shader"] << shader;
383 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
386 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
388 std::stringstream out;
389 out << target << ", " << level << ", " << width << ", " << height;
391 TraceCallStack::NamedParams namedParams;
392 namedParams["target"] << std::hex << target;
393 namedParams["level"] << level;
394 namedParams["internalformat"] << internalformat;
395 namedParams["width"] << width;
396 namedParams["height"] << height;
397 namedParams["border"] << border;
398 namedParams["size"] << imageSize;
400 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
403 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
405 std::stringstream out;
406 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
408 TraceCallStack::NamedParams namedParams;
409 namedParams["target"] << std::hex << target;
410 namedParams["level"] << level;
411 namedParams["xoffset"] << xoffset;
412 namedParams["yoffset"] << yoffset;
413 namedParams["width"] << width;
414 namedParams["height"] << height;
415 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
418 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
422 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
426 inline GLuint CreateProgram(void) override
428 mShaderTrace.PushCall("CreateProgram", "");
430 ++mLastProgramIdUsed;
431 mUniforms[mLastProgramIdUsed] = UniformIDMap();
432 return mLastProgramIdUsed;
435 inline GLuint CreateShader(GLenum type) override
437 std::stringstream out;
440 TraceCallStack::NamedParams namedParams;
441 namedParams["type"] << std::hex << type;
442 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
444 return ++mLastShaderIdUsed;
447 inline void CullFace(GLenum mode) override
449 std::stringstream out;
450 out << std::hex << mode;
452 TraceCallStack::NamedParams namedParams;
453 namedParams["mode"] << std::hex << mode;
455 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
458 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
462 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
466 inline void DeleteProgram(GLuint program) override
468 std::stringstream out;
471 TraceCallStack::NamedParams namedParams;
472 namedParams["program"] << program;
474 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
477 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
481 inline void DeleteShader(GLuint shader) override
483 std::stringstream out;
486 TraceCallStack::NamedParams namedParams;
487 namedParams["shader"] << shader;
489 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
492 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
494 std::stringstream out;
495 out << "n:" << n << " textures[";
497 TraceCallStack::NamedParams namedParams;
499 for(GLsizei i = 0; i < n; i++)
501 out << (i > 0 ? ", " : "") << textures[i];
502 std::stringstream paramName;
503 paramName << "texture[" << i << "]";
504 namedParams[paramName.str()] << textures[i];
505 mDeletedTextureIds.push_back(textures[i]);
506 mNumGeneratedTextures--;
510 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
513 inline bool CheckNoTexturesDeleted()
515 return mDeletedTextureIds.size() == 0;
518 inline bool CheckTextureDeleted(GLuint textureId)
522 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
524 if(*iter == textureId)
533 inline void ClearDeletedTextures()
535 mDeletedTextureIds.clear();
538 inline void DepthFunc(GLenum func) override
540 std::stringstream out;
541 out << std::hex << func;
543 TraceCallStack::NamedParams namedParams;
544 namedParams["func"] << std::hex << func;
546 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
549 inline void DepthMask(GLboolean flag) override
551 mLastDepthMask = flag;
554 inline bool GetLastDepthMask() const
556 return mLastDepthMask;
559 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
563 inline void DetachShader(GLuint program, GLuint shader) override
565 std::stringstream out;
566 out << program << ", " << shader;
567 TraceCallStack::NamedParams namedParams;
568 namedParams["program"] << program;
569 namedParams["shader"] << shader;
570 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
573 inline void Disable(GLenum cap) override
575 std::stringstream out;
576 out << std::hex << cap;
577 TraceCallStack::NamedParams namedParams;
578 namedParams["cap"] << std::hex << cap;
579 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
582 inline void DisableVertexAttribArray(GLuint index) override
584 std::stringstream out;
586 TraceCallStack::NamedParams namedParams;
587 namedParams["index"] << index;
588 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
589 SetVertexAttribArray(index, false);
592 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
594 std::stringstream out;
595 out << mode << ", " << first << ", " << count;
596 TraceCallStack::NamedParams namedParams;
597 namedParams["mode"] << std::hex << mode;
598 namedParams["first"] << first;
599 namedParams["count"] << count;
600 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
603 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
605 std::stringstream out;
606 out << mode << ", " << count << ", " << type << ", indices";
608 TraceCallStack::NamedParams namedParams;
609 namedParams["mode"] << std::hex << mode;
610 namedParams["count"] << count;
611 namedParams["type"] << type;
612 // Skip void pointers - are they of any use?
613 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
616 inline void Enable(GLenum cap) override
618 std::stringstream out;
619 out << std::hex << cap;
620 TraceCallStack::NamedParams namedParams;
621 namedParams["cap"] << std::hex << cap;
622 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
625 inline void EnableVertexAttribArray(GLuint index) override
627 std::stringstream out;
629 TraceCallStack::NamedParams namedParams;
630 namedParams["index"] << index;
631 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
632 SetVertexAttribArray(index, true);
635 inline void Finish(void) override
639 inline void Flush(void) override
643 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
645 if(attachment == GL_DEPTH_ATTACHMENT)
647 mFramebufferDepthAttached = true;
649 else if(attachment == GL_STENCIL_ATTACHMENT)
651 mFramebufferStencilAttached = true;
653 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
655 mFramebufferStencilAttached = true;
656 mFramebufferDepthAttached = true;
657 mFramebufferDepthStencilAttached = true;
661 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
664 mFramebufferStatus |= 4;
666 //We check 4 attachment colors
667 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
669 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
670 if((mFrameBufferColorStatus & mask) == 0)
672 mFrameBufferColorStatus |= mask;
673 ++mFramebufferColorAttachmentCount;
676 else if(attachment == GL_DEPTH_ATTACHMENT)
678 ++mFramebufferDepthAttachmentCount;
680 else if(attachment == GL_STENCIL_ATTACHMENT)
682 ++mFramebufferStencilAttachmentCount;
684 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
686 ++mFramebufferDepthAttachmentCount;
687 ++mFramebufferStencilAttachmentCount;
688 ++mFramebufferDepthStencilAttachmentCount;
692 inline void FrontFace(GLenum mode) override
697 inline void GenBuffers(GLsizei n, GLuint* buffers) override
699 // avoids an assert in GpuBuffers
702 std::ostringstream o;
704 TraceCallStack::NamedParams namedParams;
705 namedParams["n"] << o.str();
706 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
709 inline void GenerateMipmap(GLenum target) override
711 std::stringstream out;
713 TraceCallStack::NamedParams namedParams;
714 namedParams["target"] << std::hex << target;
716 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
719 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
721 for(int i = 0; i < n; i++)
723 framebuffers[i] = i + 1;
726 //Add 001 bit, this function needs to be called the first one in the chain
727 mFramebufferStatus = 1;
730 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
732 for(int i = 0; i < n; i++)
734 renderbuffers[i] = i + 1;
739 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
740 * @param[in] ids A vector containing the next IDs to be generated
742 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
744 mNextTextureIds = ids;
747 inline const std::vector<GLuint>& GetNextTextureIds()
749 return mNextTextureIds;
752 inline void GenTextures(GLsizei count, GLuint* textures) override
754 for(int i = 0; i < count; ++i)
756 if(!mNextTextureIds.empty())
758 *(textures + i) = mNextTextureIds[0];
759 mNextTextureIds.erase(mNextTextureIds.begin());
763 *(textures + i) = ++mLastAutoTextureIdUsed;
765 mNumGeneratedTextures++;
768 TraceCallStack::NamedParams namedParams;
769 namedParams["count"] << count;
771 std::stringstream out;
772 for(int i = 0; i < count; i++)
779 std::ostringstream oss;
780 oss << "indices[" << i << "]";
781 namedParams[oss.str()] << textures[i];
784 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
787 inline GLuint GetLastGenTextureId()
789 return mLastAutoTextureIdUsed;
792 inline GLuint GetNumGeneratedTextures()
794 return mNumGeneratedTextures;
797 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
801 inline void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms)
803 mActiveUniforms = uniforms;
806 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
808 if(index < mActiveUniforms.size())
810 *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
811 *type = mActiveUniforms[index].type;
812 *size = mActiveUniforms[index].size;
816 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
820 inline int GetAttribLocation(GLuint program, const char* name) override
822 std::string check(name);
823 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
824 if(iter == mAttribLocs.end())
826 return iter - mAttribLocs.begin();
829 inline void GetBooleanv(GLenum pname, GLboolean* params) override
833 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
837 inline GLenum GetError(void) override
839 return mGetErrorResult;
842 inline void GetFloatv(GLenum pname, GLfloat* params) override
846 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
850 inline void GetIntegerv(GLenum pname, GLint* params) override
854 case GL_MAX_TEXTURE_SIZE:
857 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
860 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
861 *params = mNumBinaryFormats;
863 case GL_PROGRAM_BINARY_FORMATS_OES:
864 *params = mBinaryFormats;
869 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
874 *params = mLinkStatus;
876 case GL_PROGRAM_BINARY_LENGTH_OES:
877 *params = mProgramBinaryLength;
879 case GL_ACTIVE_UNIFORMS:
880 *params = mActiveUniforms.size();
882 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
885 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
891 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
895 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
899 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
903 case GL_COMPILE_STATUS:
904 *params = mCompileStatus;
909 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
913 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
917 inline const GLubyte* GetString(GLenum name) override
919 return mGetStringResult;
922 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
926 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
930 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
934 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
938 inline GLint GetUniformLocation(GLuint program, const char* name) override
940 ProgramUniformMap::iterator it = mUniforms.find(program);
941 if(it == mUniforms.end())
943 // Not a valid program ID
944 mGetErrorResult = GL_INVALID_OPERATION;
948 UniformIDMap& uniformIDs = it->second;
949 UniformIDMap::iterator it2 = uniformIDs.find(name);
950 if(it2 == uniformIDs.end())
952 // Uniform not found, so add it...
953 uniformIDs[name] = ++mLastUniformIdUsed;
954 return uniformIDs[name];
960 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
964 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
968 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
972 inline void Hint(GLenum target, GLenum mode) override
976 inline GLboolean IsBuffer(GLuint buffer) override
978 return mIsBufferResult;
981 inline GLboolean IsEnabled(GLenum cap) override
983 return mIsEnabledResult;
986 inline GLboolean IsFramebuffer(GLuint framebuffer) override
988 return mIsFramebufferResult;
991 inline GLboolean IsProgram(GLuint program) override
993 return mIsProgramResult;
996 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
998 return mIsRenderbufferResult;
1001 inline GLboolean IsShader(GLuint shader) override
1003 return mIsShaderResult;
1006 inline GLboolean IsTexture(GLuint texture) override
1008 return mIsTextureResult;
1011 inline void LineWidth(GLfloat width) override
1015 inline void LinkProgram(GLuint program) override
1017 std::stringstream out;
1020 TraceCallStack::NamedParams namedParams;
1021 namedParams["program"] << program;
1022 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
1024 for(const auto& uniform : mActiveUniforms)
1026 GetUniformLocation(program, uniform.name.c_str());
1029 for(const auto& uniform : mCustomUniformData)
1031 auto iter = uniform.name.find("[");
1032 auto name = uniform.name;
1033 if(iter != std::string::npos)
1035 name = uniform.name.substr(0, iter);
1036 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1037 iter = uniform.name.find("]");
1039 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1041 suffix = uniform.name.substr(iter + 1); // If there is a suffix, it means its an element of an array of struct
1044 for(int i = 0; i < arrayCount; ++i)
1046 std::stringstream nss;
1047 nss << name << "[" << i << "]" << suffix;
1048 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1053 GetUniformLocation(program, name.c_str());
1058 inline void PixelStorei(GLenum pname, GLint param) override
1062 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1066 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1070 inline void ReleaseShaderCompiler(void) override
1074 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1078 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1082 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1084 mScissorParams.x = x;
1085 mScissorParams.y = y;
1086 mScissorParams.width = width;
1087 mScissorParams.height = height;
1089 std::stringstream out;
1090 out << x << ", " << y << ", " << width << ", " << height;
1091 TraceCallStack::NamedParams namedParams;
1092 namedParams["x"] << x;
1093 namedParams["y"] << y;
1094 namedParams["width"] << width;
1095 namedParams["height"] << height;
1096 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1099 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1103 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1105 std::string stringBuilder;
1106 for(int i = 0; i < count; ++i)
1108 stringBuilder += string[i];
1110 mShaderSources[shader] = stringBuilder;
1111 mLastShaderCompiled = shader;
1114 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1116 const std::string shaderSource = mShaderSources[shader];
1117 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1118 if(shaderSourceLength < bufsize)
1120 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1121 *length = shaderSourceLength;
1125 *length = bufsize - 1;
1126 strncpy(source, shaderSource.c_str(), *length);
1127 source[*length] = 0x0;
1131 inline std::string GetShaderSource(GLuint shader)
1133 return mShaderSources[shader];
1136 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1138 std::stringstream out;
1139 out << func << ", " << ref << ", " << mask;
1141 TraceCallStack::NamedParams namedParams;
1142 namedParams["func"] << std::hex << func;
1143 namedParams["ref"] << ref;
1144 namedParams["mask"] << mask;
1146 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1149 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1151 std::stringstream out;
1152 out << face << ", " << func << ", " << ref << ", " << mask;
1154 TraceCallStack::NamedParams namedParams;
1155 namedParams["face"] << std::hex << face;
1156 namedParams["func"] << std::hex << func;
1157 namedParams["ref"] << ref;
1158 namedParams["mask"] << mask;
1160 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1163 inline void StencilMask(GLuint mask) override
1165 std::stringstream out;
1168 TraceCallStack::NamedParams namedParams;
1169 namedParams["mask"] << mask;
1171 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1174 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1176 std::stringstream out;
1177 out << face << ", " << mask;
1179 TraceCallStack::NamedParams namedParams;
1180 namedParams["face"] << std::hex << face;
1181 namedParams["mask"] << mask;
1183 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1186 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1188 std::stringstream out;
1189 out << fail << ", " << zfail << ", " << zpass;
1191 TraceCallStack::NamedParams namedParams;
1192 namedParams["fail"] << std::hex << fail;
1193 namedParams["zfail"] << std::hex << zfail;
1194 namedParams["zpass"] << std::hex << zpass;
1196 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1199 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1201 std::stringstream out;
1202 out << face << ", " << fail << ", " << zfail << "," << zpass;
1204 TraceCallStack::NamedParams namedParams;
1205 namedParams["face"] << std::hex << face;
1206 namedParams["fail"] << std::hex << fail;
1207 namedParams["zfail"] << std::hex << zfail;
1208 namedParams["zpass"] << std::hex << zpass;
1210 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1213 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1215 std::stringstream out;
1216 out << target << ", " << level << ", " << width << ", " << height;
1218 TraceCallStack::NamedParams namedParams;
1219 namedParams["target"] << std::hex << target;
1220 namedParams["level"] << level;
1221 namedParams["internalformat"] << internalformat;
1222 namedParams["width"] << width;
1223 namedParams["height"] << height;
1224 namedParams["border"] << border;
1225 namedParams["format"] << std::hex << format;
1226 namedParams["type"] << std::hex << type;
1228 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1231 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1233 std::stringstream out;
1234 out << target << ", " << pname << ", " << param;
1236 TraceCallStack::NamedParams namedParams;
1237 namedParams["target"] << std::hex << target;
1238 namedParams["pname"] << std::hex << pname;
1239 namedParams["param"] << param;
1241 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1244 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1246 std::stringstream out;
1247 out << target << ", " << pname << ", " << params[0];
1249 TraceCallStack::NamedParams namedParams;
1250 namedParams["target"] << std::hex << target;
1251 namedParams["pname"] << std::hex << pname;
1252 namedParams["params[0]"] << params[0];
1254 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1257 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1259 std::stringstream out;
1260 out << std::hex << target << ", " << pname << ", " << param;
1261 std::string params = out.str();
1263 TraceCallStack::NamedParams namedParams;
1264 namedParams["target"] << std::hex << target;
1265 namedParams["pname"] << std::hex << pname;
1266 namedParams["param"] << param;
1267 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1270 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1272 std::stringstream out;
1273 out << target << ", " << pname << ", " << params[0];
1274 TraceCallStack::NamedParams namedParams;
1275 namedParams["target"] << std::hex << target;
1276 namedParams["pname"] << std::hex << pname;
1277 namedParams["params[0]"] << params[0];
1278 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1281 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1283 std::stringstream out;
1284 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1286 TraceCallStack::NamedParams namedParams;
1287 namedParams["target"] << std::hex << target;
1288 namedParams["level"] << level;
1289 namedParams["xoffset"] << xoffset;
1290 namedParams["yoffset"] << yoffset;
1291 namedParams["width"] << width;
1292 namedParams["height"] << height;
1293 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1296 inline void Uniform1f(GLint location, GLfloat value) override
1298 std::string params = std::to_string(value);
1299 AddUniformCallToTraceStack(location, params);
1301 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1303 mGetErrorResult = GL_INVALID_OPERATION;
1307 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1310 for(int i = 0; i < count; ++i)
1312 params = params + std::to_string(v[i]) + ",";
1315 AddUniformCallToTraceStack(location, params);
1317 for(int i = 0; i < count; ++i)
1319 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1321 mGetErrorResult = GL_INVALID_OPERATION;
1327 inline void Uniform1i(GLint location, GLint x) override
1329 std::string params = std::to_string(x);
1331 AddUniformCallToTraceStack(location, params);
1333 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1335 mGetErrorResult = GL_INVALID_OPERATION;
1339 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1341 std::ostringstream out;
1342 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1343 AddUniformCallToTraceStack(location, out.str());
1345 for(int i = 0; i < count; ++i)
1347 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1351 mGetErrorResult = GL_INVALID_OPERATION;
1357 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1359 std::string params = std::to_string(x) + "," + std::to_string(y);
1360 AddUniformCallToTraceStack(location, params);
1362 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1366 mGetErrorResult = GL_INVALID_OPERATION;
1370 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1372 std::ostringstream out;
1373 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1374 AddUniformCallToTraceStack(location, out.str());
1376 for(int i = 0; i < count; ++i)
1378 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1380 Vector2(v[2 * i], v[2 * i + 1])))
1382 mGetErrorResult = GL_INVALID_OPERATION;
1388 inline void Uniform2i(GLint location, GLint x, GLint y) override
1390 std::string params = std::to_string(x) + "," + std::to_string(y);
1391 AddUniformCallToTraceStack(location, params);
1394 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1396 std::ostringstream out;
1397 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1398 AddUniformCallToTraceStack(location, out.str());
1401 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1403 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1404 AddUniformCallToTraceStack(location, params);
1406 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1410 mGetErrorResult = GL_INVALID_OPERATION;
1414 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1416 std::ostringstream out;
1417 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1418 AddUniformCallToTraceStack(location, out.str());
1420 for(int i = 0; i < count; ++i)
1422 if(!mProgramUniforms3f.SetUniformValue(
1425 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1427 mGetErrorResult = GL_INVALID_OPERATION;
1433 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1435 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1436 AddUniformCallToTraceStack(location, params);
1439 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1441 std::ostringstream out;
1442 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1443 AddUniformCallToTraceStack(location, out.str());
1446 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1448 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1449 AddUniformCallToTraceStack(location, params);
1451 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1453 Vector4(x, y, z, w)))
1455 mGetErrorResult = GL_INVALID_OPERATION;
1459 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1461 std::ostringstream out;
1462 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1463 AddUniformCallToTraceStack(location, out.str());
1465 for(int i = 0; i < count; ++i)
1467 if(!mProgramUniforms4f.SetUniformValue(
1470 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1472 mGetErrorResult = GL_INVALID_OPERATION;
1478 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1480 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1481 AddUniformCallToTraceStack(location, params);
1484 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1486 std::ostringstream out;
1487 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1488 AddUniformCallToTraceStack(location, out.str());
1491 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1493 std::ostringstream out;
1494 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1495 AddUniformCallToTraceStack(location, out.str());
1498 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1500 std::ostringstream out;
1501 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1502 AddUniformCallToTraceStack(location, out.str());
1504 for(int i = 0; i < count; ++i)
1506 if(!mProgramUniformsMat3.SetUniformValue(
1509 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1511 mGetErrorResult = GL_INVALID_OPERATION;
1517 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1519 std::ostringstream out;
1520 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1521 AddUniformCallToTraceStack(location, out.str());
1523 for(int i = 0; i < count; ++i)
1525 if(!mProgramUniformsMat4.SetUniformValue(
1530 mGetErrorResult = GL_INVALID_OPERATION;
1536 inline void UseProgram(GLuint program) override
1538 mCurrentProgram = program;
1541 inline void ValidateProgram(GLuint program) override
1545 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1549 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1553 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1557 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1561 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1565 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1569 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1573 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1577 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1579 TraceCallStack::NamedParams namedParams;
1580 namedParams["index"] << index;
1581 namedParams["size"] << size;
1582 namedParams["type"] << std::hex << type;
1583 namedParams["normalized"] << (normalized ? "T" : "F");
1584 namedParams["stride"] << stride;
1585 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1587 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1590 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1592 std::string commaString(", ");
1593 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1595 mViewportTrace.PushCall("Viewport", params);
1600 inline void ReadBuffer(GLenum mode) override
1604 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1608 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
1612 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
1616 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1620 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1624 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
1628 inline void GenQueries(GLsizei n, GLuint* ids) override
1632 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1636 inline GLboolean IsQuery(GLuint id) override
1641 inline void BeginQuery(GLenum target, GLuint id) override
1645 inline void EndQuery(GLenum target) override
1649 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1653 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1657 inline GLboolean UnmapBuffer(GLenum target) override
1661 free(mMappedBuffer);
1662 mMappedBuffer = nullptr;
1664 return true; // false indicates corruption, nothing else.
1667 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1671 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1675 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1679 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1683 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1687 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1691 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1695 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1699 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1703 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1707 inline void FramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) override
1709 // TODO : Check it if need
1710 FramebufferTexture2D(target, attachment, textarget, texture, level);
1713 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1717 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1719 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1720 return mMappedBuffer;
1723 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1727 inline void BindVertexArray(GLuint array) override
1731 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1735 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1739 inline GLboolean IsVertexArray(GLuint array) override
1744 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1748 inline void BeginTransformFeedback(GLenum primitiveMode) override
1752 inline void EndTransformFeedback(void) override
1756 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1760 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1764 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1768 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1772 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1776 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1780 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1784 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1788 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1792 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1796 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1800 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1804 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1809 inline void Uniform1ui(GLint location, GLuint v0) override
1813 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1817 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1821 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1825 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1829 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1833 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1837 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1841 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1845 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1849 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1853 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1857 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1862 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1866 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1870 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1874 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1876 return GL_INVALID_INDEX;
1879 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1883 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1887 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1891 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1895 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1899 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1904 inline GLboolean IsSync(GLsync sync) override
1909 inline void DeleteSync(GLsync sync) override
1913 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1918 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1922 inline void GetInteger64v(GLenum pname, GLint64* params) override
1926 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1930 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1934 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1938 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1942 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1946 inline GLboolean IsSampler(GLuint sampler) override
1951 inline void BindSampler(GLuint unit, GLuint sampler) override
1955 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1959 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1963 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1967 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1971 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1975 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1979 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1983 inline void BindTransformFeedback(GLenum target, GLuint id) override
1987 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1991 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1995 inline GLboolean IsTransformFeedback(GLuint id) override
2000 inline void PauseTransformFeedback(void) override
2004 inline void ResumeTransformFeedback(void) override
2008 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2010 mGetProgramBinaryCalled = true;
2013 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2017 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2021 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2025 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2029 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2033 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2037 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2041 inline void BlendBarrier(void)
2046 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2048 std::string name = "<not found>";
2049 bool matched = false;
2051 UniformIDMap& map = mUniforms[mCurrentProgram];
2052 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2054 if(it->second == location)
2064 mSetUniformTrace.PushCall(name, value);
2068 public: // TEST FUNCTIONS
2069 inline void SetCompileStatus(GLuint value)
2071 mCompileStatus = value;
2073 inline void SetLinkStatus(GLuint value)
2075 mLinkStatus = value;
2077 inline void SetAttribLocations(std::vector<std::string> locs)
2081 inline void SetGetErrorResult(GLenum result)
2083 mGetErrorResult = result;
2085 inline void SetGetStringResult(GLubyte* result)
2087 mGetStringResult = result;
2089 inline void SetIsBufferResult(GLboolean result)
2091 mIsBufferResult = result;
2093 inline void SetIsEnabledResult(GLboolean result)
2095 mIsEnabledResult = result;
2097 inline void SetIsFramebufferResult(GLboolean result)
2099 mIsFramebufferResult = result;
2101 inline void SetIsProgramResult(GLboolean result)
2103 mIsProgramResult = result;
2105 inline void SetIsRenderbufferResult(GLboolean result)
2107 mIsRenderbufferResult = result;
2109 inline void SetIsShaderResult(GLboolean result)
2111 mIsShaderResult = result;
2113 inline void SetIsTextureResult(GLboolean result)
2115 mIsTextureResult = result;
2117 inline void SetCheckFramebufferStatusResult(GLenum result)
2119 mCheckFramebufferStatusResult = result;
2121 inline void SetNumBinaryFormats(GLint numFormats)
2123 mNumBinaryFormats = numFormats;
2125 inline void SetBinaryFormats(GLint binaryFormats)
2127 mBinaryFormats = binaryFormats;
2129 inline void SetProgramBinaryLength(GLint length)
2131 mProgramBinaryLength = length;
2134 inline bool GetVertexAttribArrayState(GLuint index)
2136 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2141 return mVertexAttribArrayState[index];
2143 inline void ClearVertexAttribArrayChanged()
2145 mVertexAttribArrayChanged = false;
2147 inline bool GetVertexAttribArrayChanged()
2149 return mVertexAttribArrayChanged;
2152 //Methods for CullFace verification
2153 inline void EnableCullFaceCallTrace(bool enable)
2155 mCullFaceTrace.Enable(enable);
2157 inline void ResetCullFaceCallStack()
2159 mCullFaceTrace.Reset();
2161 inline TraceCallStack& GetCullFaceTrace()
2163 return mCullFaceTrace;
2166 //Methods for Enable/Disable call verification
2167 inline void EnableEnableDisableCallTrace(bool enable)
2169 mEnableDisableTrace.Enable(enable);
2171 inline void ResetEnableDisableCallStack()
2173 mEnableDisableTrace.Reset();
2175 inline TraceCallStack& GetEnableDisableTrace()
2177 return mEnableDisableTrace;
2180 //Methods for Shader verification
2181 inline void EnableShaderCallTrace(bool enable)
2183 mShaderTrace.Enable(enable);
2185 inline void ResetShaderCallStack()
2187 mShaderTrace.Reset();
2189 inline TraceCallStack& GetShaderTrace()
2191 return mShaderTrace;
2194 //Methods for Texture verification
2195 inline void EnableTextureCallTrace(bool enable)
2197 mTextureTrace.Enable(enable);
2199 inline void ResetTextureCallStack()
2201 mTextureTrace.Reset();
2203 inline TraceCallStack& GetTextureTrace()
2205 return mTextureTrace;
2208 //Methods for Texture verification
2209 inline void EnableTexParameterCallTrace(bool enable)
2211 mTexParameterTrace.Enable(enable);
2213 inline void ResetTexParameterCallStack()
2215 mTexParameterTrace.Reset();
2217 inline TraceCallStack& GetTexParameterTrace()
2219 return mTexParameterTrace;
2222 //Methods for Draw verification
2223 inline void EnableDrawCallTrace(bool enable)
2225 mDrawTrace.Enable(enable);
2227 inline void ResetDrawCallStack()
2231 inline TraceCallStack& GetDrawTrace()
2236 //Methods for Depth function verification
2237 inline void EnableDepthFunctionCallTrace(bool enable)
2239 mDepthFunctionTrace.Enable(enable);
2241 inline void ResetDepthFunctionCallStack()
2243 mDepthFunctionTrace.Reset();
2245 inline TraceCallStack& GetDepthFunctionTrace()
2247 return mDepthFunctionTrace;
2250 //Methods for Stencil function verification
2251 inline void EnableStencilFunctionCallTrace(bool enable)
2253 mStencilFunctionTrace.Enable(enable);
2255 inline void ResetStencilFunctionCallStack()
2257 mStencilFunctionTrace.Reset();
2259 inline TraceCallStack& GetStencilFunctionTrace()
2261 return mStencilFunctionTrace;
2264 //Methods for Scissor verification
2265 inline void EnableScissorCallTrace(bool enable)
2267 mScissorTrace.Enable(enable);
2269 inline void ResetScissorCallStack()
2271 mScissorTrace.Reset();
2273 inline TraceCallStack& GetScissorTrace()
2275 return mScissorTrace;
2278 //Methods for Uniform function verification
2279 inline void EnableSetUniformCallTrace(bool enable)
2281 mSetUniformTrace.Enable(enable);
2283 inline void ResetSetUniformCallStack()
2285 mSetUniformTrace.Reset();
2287 inline TraceCallStack& GetSetUniformTrace()
2289 return mSetUniformTrace;
2292 //Methods for Viewport verification
2293 inline void EnableViewportCallTrace(bool enable)
2295 mViewportTrace.Enable(enable);
2297 inline void ResetViewportCallStack()
2299 mViewportTrace.Reset();
2301 inline TraceCallStack& GetViewportTrace()
2303 return mViewportTrace;
2305 inline TraceCallStack& GetBufferTrace()
2307 return mBufferTrace;
2310 template<typename T>
2311 inline bool GetUniformValue(const char* name, T& value) const
2313 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2314 program_it != mUniforms.end();
2317 const UniformIDMap& uniformIDs = program_it->second;
2319 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2320 if(uniform_it != uniformIDs.end())
2322 // found one matching uniform name, lets check the value...
2323 GLuint programId = program_it->first;
2324 GLint uniformId = uniform_it->second;
2326 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2327 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2333 template<typename T>
2334 inline bool CheckUniformValue(const char* name, const T& value) const
2336 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2337 program_it != mUniforms.end();
2340 const UniformIDMap& uniformIDs = program_it->second;
2342 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2343 if(uniform_it != uniformIDs.end())
2345 // found one matching uniform name, lets check the value...
2346 GLuint programId = program_it->first;
2347 GLint uniformId = uniform_it->second;
2349 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2350 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2352 // the value matches
2358 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2359 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2360 program_it != mUniforms.end();
2363 const UniformIDMap& uniformIDs = program_it->second;
2365 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2366 if(uniform_it != uniformIDs.end())
2368 // found one matching uniform name, lets check the value...
2369 GLuint programId = program_it->first;
2370 GLint uniformId = uniform_it->second;
2372 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2374 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2376 std::stringstream out;
2377 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2378 fprintf(stderr, "%s\n", out.str().c_str());
2385 template<typename T>
2386 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2388 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2389 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2392 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2394 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2395 program_it != mUniforms.end();
2398 const UniformIDMap& uniformIDs = program_it->second;
2400 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2401 if(uniform_it != uniformIDs.end())
2403 programId = program_it->first;
2404 uniformId = uniform_it->second;
2411 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2413 mCustomUniformData = customUniformData;
2416 inline GLuint GetLastShaderCompiled() const
2418 return mLastShaderCompiled;
2421 inline GLuint GetLastProgramCreated() const
2423 return mLastProgramIdUsed;
2426 inline GLbitfield GetLastClearMask() const
2428 return mLastClearBitMask;
2433 ATTRIB_UNKNOWN = -1,
2438 ATTRIB_BONE_WEIGHTS,
2439 ATTRIB_BONE_INDICES,
2443 struct ScissorParams
2459 // Methods to check scissor tests
2460 inline const ScissorParams& GetScissorParams() const
2462 return mScissorParams;
2465 struct ColorMaskParams
2481 inline bool GetProgramBinaryCalled() const
2483 return mGetProgramBinaryCalled;
2486 inline unsigned int GetClearCountCalled() const
2491 inline const ColorMaskParams& GetColorMaskParams() const
2493 return mColorMaskParams;
2496 typedef std::vector<size_t> BufferDataCalls;
2497 inline const BufferDataCalls& GetBufferDataCalls() const
2499 return mBufferDataCalls;
2501 inline void ResetBufferDataCalls()
2503 mBufferDataCalls.clear();
2506 typedef std::vector<size_t> BufferSubDataCalls;
2507 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2509 return mBufferSubDataCalls;
2511 inline void ResetBufferSubDataCalls()
2513 mBufferSubDataCalls.clear();
2517 GLuint mCurrentProgram;
2518 GLuint mCompileStatus;
2519 BufferDataCalls mBufferDataCalls;
2520 BufferSubDataCalls mBufferSubDataCalls;
2521 GLvoid* mMappedBuffer{nullptr};
2523 GLenum mGetErrorResult;
2524 GLubyte* mGetStringResult;
2525 GLboolean mIsBufferResult;
2526 GLboolean mIsEnabledResult;
2527 GLboolean mIsFramebufferResult;
2528 GLboolean mIsProgramResult;
2529 GLboolean mIsRenderbufferResult;
2530 GLboolean mIsShaderResult;
2531 GLboolean mIsTextureResult;
2532 GLenum mActiveTextureUnit;
2533 GLenum mCheckFramebufferStatusResult;
2534 GLint mFramebufferStatus;
2535 GLenum mFramebufferDepthAttached;
2536 GLenum mFramebufferStencilAttached;
2537 GLenum mFramebufferDepthStencilAttached;
2538 GLuint mFramebufferColorAttachmentCount;
2539 GLuint mFrameBufferColorStatus;
2540 GLuint mFramebufferDepthAttachmentCount;
2541 GLuint mFramebufferStencilAttachmentCount;
2542 GLuint mFramebufferDepthStencilAttachmentCount;
2543 GLint mNumBinaryFormats;
2544 GLint mBinaryFormats;
2545 GLint mProgramBinaryLength;
2546 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2547 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2548 bool mGetProgramBinaryCalled;
2549 typedef std::map<GLuint, std::string> ShaderSourceMap;
2550 ShaderSourceMap mShaderSources;
2551 std::vector<std::string> mAttribLocs; // should be bound to shader
2552 GLuint mLastShaderCompiled;
2553 GLbitfield mLastClearBitMask;
2554 Vector4 mLastClearColor;
2555 unsigned int mClearCount;
2557 Vector4 mLastBlendColor;
2558 GLenum mLastBlendEquationRgb;
2559 GLenum mLastBlendEquationAlpha;
2560 GLenum mLastBlendFuncSrcRgb;
2561 GLenum mLastBlendFuncDstRgb;
2562 GLenum mLastBlendFuncSrcAlpha;
2563 GLenum mLastBlendFuncDstAlpha;
2565 GLboolean mLastDepthMask;
2567 // Data for manipulating the IDs returned by GenTextures
2568 GLuint mLastAutoTextureIdUsed;
2569 GLuint mNumGeneratedTextures;
2570 std::vector<GLuint> mNextTextureIds;
2571 std::vector<GLuint> mDeletedTextureIds;
2572 std::vector<GLuint> mBoundTextures;
2574 struct ActiveTextureType
2576 std::vector<GLuint> mBoundTextures;
2579 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2581 TraceCallStack mBufferTrace;
2582 TraceCallStack mCullFaceTrace;
2583 TraceCallStack mEnableDisableTrace;
2584 TraceCallStack mShaderTrace;
2585 TraceCallStack mTextureTrace;
2586 TraceCallStack mTexParameterTrace;
2587 TraceCallStack mDrawTrace;
2588 TraceCallStack mDepthFunctionTrace;
2589 TraceCallStack mStencilFunctionTrace;
2590 TraceCallStack mScissorTrace;
2591 TraceCallStack mSetUniformTrace;
2592 TraceCallStack mViewportTrace;
2594 // Shaders & Uniforms
2595 GLuint mLastShaderIdUsed;
2596 GLuint mLastProgramIdUsed{0u};
2597 GLuint mLastUniformIdUsed;
2598 typedef std::map<std::string, GLint> UniformIDMap;
2599 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2600 ProgramUniformMap mUniforms;
2601 std::vector<ActiveUniform> mActiveUniforms;
2602 std::vector<UniformData> mCustomUniformData{};
2604 template<typename T>
2605 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2608 typedef std::map<GLint, T> UniformValueMap;
2609 typedef std::map<GLuint, UniformValueMap> Map;
2611 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2618 typename Map::iterator it = Map::find(program);
2619 if(it == Map::end())
2621 // if its the first uniform for this program add it
2622 std::pair<typename Map::iterator, bool> result =
2623 Map::insert(typename Map::value_type(program, UniformValueMap()));
2627 UniformValueMap& uniforms = it->second;
2628 uniforms[uniform] = value;
2633 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2636 if(GetUniformValue(program, uniform, uniformValue))
2638 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2644 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2651 typename Map::const_iterator it = Map::find(program);
2652 if(it == Map::end())
2654 // Uniform values always initialised as 0
2659 const UniformValueMap& uniforms = it->second;
2660 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2661 if(it2 == uniforms.end())
2663 // Uniform values always initialised as 0
2667 value = it2->second;
2674 ProgramUniformValue<int> mProgramUniforms1i;
2675 ProgramUniformValue<float> mProgramUniforms1f;
2676 ProgramUniformValue<Vector2> mProgramUniforms2f;
2677 ProgramUniformValue<Vector3> mProgramUniforms3f;
2678 ProgramUniformValue<Vector4> mProgramUniforms4f;
2679 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2680 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2682 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2684 return mProgramUniforms1i;
2686 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2688 return mProgramUniforms1f;
2690 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2692 return mProgramUniforms2f;
2694 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2696 return mProgramUniforms3f;
2698 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2700 return mProgramUniforms4f;
2702 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2704 return mProgramUniformsMat4;
2706 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2708 return mProgramUniformsMat3;
2710 inline void SetVertexAttribArray(GLuint index, bool state)
2712 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2717 mVertexAttribArrayState[index] = state;
2718 mVertexAttribArrayChanged = true;
2721 ScissorParams mScissorParams;
2722 ColorMaskParams mColorMaskParams;
2726 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2732 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2738 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2740 return Vector2::ZERO;
2744 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2746 return Vector3::ZERO;
2750 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2752 return Vector4::ZERO;
2756 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2762 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2764 return Matrix3(Matrix());
2769 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2770 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2772 #endif // TEST_GL_ABSTRACTION_H