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:
888 case GL_ACTIVE_ATTRIBUTES:
889 *params = static_cast<GLint>(mAttribLocs.size());
894 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
898 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
902 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
906 case GL_COMPILE_STATUS:
907 *params = mCompileStatus;
912 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
916 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
920 inline const GLubyte* GetString(GLenum name) override
922 return mGetStringResult;
925 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
929 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
933 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
937 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
941 inline GLint GetUniformLocation(GLuint program, const char* name) override
943 ProgramUniformMap::iterator it = mUniforms.find(program);
944 if(it == mUniforms.end())
946 // Not a valid program ID
947 mGetErrorResult = GL_INVALID_OPERATION;
951 UniformIDMap& uniformIDs = it->second;
952 UniformIDMap::iterator it2 = uniformIDs.find(name);
953 if(it2 == uniformIDs.end())
955 // Uniform not found, so add it...
956 uniformIDs[name] = ++mLastUniformIdUsed;
957 return uniformIDs[name];
963 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
967 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
971 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
975 inline void Hint(GLenum target, GLenum mode) override
979 inline GLboolean IsBuffer(GLuint buffer) override
981 return mIsBufferResult;
984 inline GLboolean IsEnabled(GLenum cap) override
986 return mIsEnabledResult;
989 inline GLboolean IsFramebuffer(GLuint framebuffer) override
991 return mIsFramebufferResult;
994 inline GLboolean IsProgram(GLuint program) override
996 return mIsProgramResult;
999 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
1001 return mIsRenderbufferResult;
1004 inline GLboolean IsShader(GLuint shader) override
1006 return mIsShaderResult;
1009 inline GLboolean IsTexture(GLuint texture) override
1011 return mIsTextureResult;
1014 inline void LineWidth(GLfloat width) override
1018 inline void LinkProgram(GLuint program) override
1020 std::stringstream out;
1023 TraceCallStack::NamedParams namedParams;
1024 namedParams["program"] << program;
1025 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
1027 for(const auto& uniform : mActiveUniforms)
1029 GetUniformLocation(program, uniform.name.c_str());
1032 for(const auto& uniform : mCustomUniformData)
1034 auto iter = uniform.name.find("[");
1035 auto name = uniform.name;
1036 if(iter != std::string::npos)
1038 name = uniform.name.substr(0, iter);
1039 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1040 iter = uniform.name.find("]");
1042 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1044 suffix = uniform.name.substr(iter + 1); // If there is a suffix, it means its an element of an array of struct
1047 for(int i = 0; i < arrayCount; ++i)
1049 std::stringstream nss;
1050 nss << name << "[" << i << "]" << suffix;
1051 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1056 GetUniformLocation(program, name.c_str());
1061 inline void PixelStorei(GLenum pname, GLint param) override
1065 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1069 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1073 inline void ReleaseShaderCompiler(void) override
1077 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1081 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1085 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1087 mScissorParams.x = x;
1088 mScissorParams.y = y;
1089 mScissorParams.width = width;
1090 mScissorParams.height = height;
1092 std::stringstream out;
1093 out << x << ", " << y << ", " << width << ", " << height;
1094 TraceCallStack::NamedParams namedParams;
1095 namedParams["x"] << x;
1096 namedParams["y"] << y;
1097 namedParams["width"] << width;
1098 namedParams["height"] << height;
1099 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1102 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1106 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1108 std::string stringBuilder;
1109 for(int i = 0; i < count; ++i)
1111 stringBuilder += string[i];
1113 mShaderSources[shader] = stringBuilder;
1114 mLastShaderCompiled = shader;
1117 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1119 const std::string shaderSource = mShaderSources[shader];
1120 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1121 if(shaderSourceLength < bufsize)
1123 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1124 *length = shaderSourceLength;
1128 *length = bufsize - 1;
1129 strncpy(source, shaderSource.c_str(), *length);
1130 source[*length] = 0x0;
1134 inline std::string GetShaderSource(GLuint shader)
1136 return mShaderSources[shader];
1139 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1141 std::stringstream out;
1142 out << func << ", " << ref << ", " << mask;
1144 TraceCallStack::NamedParams namedParams;
1145 namedParams["func"] << std::hex << func;
1146 namedParams["ref"] << ref;
1147 namedParams["mask"] << mask;
1149 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1152 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1154 std::stringstream out;
1155 out << face << ", " << func << ", " << ref << ", " << mask;
1157 TraceCallStack::NamedParams namedParams;
1158 namedParams["face"] << std::hex << face;
1159 namedParams["func"] << std::hex << func;
1160 namedParams["ref"] << ref;
1161 namedParams["mask"] << mask;
1163 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1166 inline void StencilMask(GLuint mask) override
1168 std::stringstream out;
1171 TraceCallStack::NamedParams namedParams;
1172 namedParams["mask"] << mask;
1174 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1177 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1179 std::stringstream out;
1180 out << face << ", " << mask;
1182 TraceCallStack::NamedParams namedParams;
1183 namedParams["face"] << std::hex << face;
1184 namedParams["mask"] << mask;
1186 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1189 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1191 std::stringstream out;
1192 out << fail << ", " << zfail << ", " << zpass;
1194 TraceCallStack::NamedParams namedParams;
1195 namedParams["fail"] << std::hex << fail;
1196 namedParams["zfail"] << std::hex << zfail;
1197 namedParams["zpass"] << std::hex << zpass;
1199 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1202 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1204 std::stringstream out;
1205 out << face << ", " << fail << ", " << zfail << "," << zpass;
1207 TraceCallStack::NamedParams namedParams;
1208 namedParams["face"] << std::hex << face;
1209 namedParams["fail"] << std::hex << fail;
1210 namedParams["zfail"] << std::hex << zfail;
1211 namedParams["zpass"] << std::hex << zpass;
1213 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1216 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1218 std::stringstream out;
1219 out << target << ", " << level << ", " << width << ", " << height;
1221 TraceCallStack::NamedParams namedParams;
1222 namedParams["target"] << std::hex << target;
1223 namedParams["level"] << level;
1224 namedParams["internalformat"] << internalformat;
1225 namedParams["width"] << width;
1226 namedParams["height"] << height;
1227 namedParams["border"] << border;
1228 namedParams["format"] << std::hex << format;
1229 namedParams["type"] << std::hex << type;
1231 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1234 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1236 std::stringstream out;
1237 out << target << ", " << pname << ", " << param;
1239 TraceCallStack::NamedParams namedParams;
1240 namedParams["target"] << std::hex << target;
1241 namedParams["pname"] << std::hex << pname;
1242 namedParams["param"] << param;
1244 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1247 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1249 std::stringstream out;
1250 out << target << ", " << pname << ", " << params[0];
1252 TraceCallStack::NamedParams namedParams;
1253 namedParams["target"] << std::hex << target;
1254 namedParams["pname"] << std::hex << pname;
1255 namedParams["params[0]"] << params[0];
1257 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1260 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1262 std::stringstream out;
1263 out << std::hex << target << ", " << pname << ", " << param;
1264 std::string params = out.str();
1266 TraceCallStack::NamedParams namedParams;
1267 namedParams["target"] << std::hex << target;
1268 namedParams["pname"] << std::hex << pname;
1269 namedParams["param"] << param;
1270 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1273 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1275 std::stringstream out;
1276 out << target << ", " << pname << ", " << params[0];
1277 TraceCallStack::NamedParams namedParams;
1278 namedParams["target"] << std::hex << target;
1279 namedParams["pname"] << std::hex << pname;
1280 namedParams["params[0]"] << params[0];
1281 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1284 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1286 std::stringstream out;
1287 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1289 TraceCallStack::NamedParams namedParams;
1290 namedParams["target"] << std::hex << target;
1291 namedParams["level"] << level;
1292 namedParams["xoffset"] << xoffset;
1293 namedParams["yoffset"] << yoffset;
1294 namedParams["width"] << width;
1295 namedParams["height"] << height;
1296 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1299 inline void Uniform1f(GLint location, GLfloat value) override
1301 std::string params = std::to_string(value);
1302 AddUniformCallToTraceStack(location, params);
1304 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1306 mGetErrorResult = GL_INVALID_OPERATION;
1310 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1313 for(int i = 0; i < count; ++i)
1315 params = params + std::to_string(v[i]) + ",";
1318 AddUniformCallToTraceStack(location, params);
1320 for(int i = 0; i < count; ++i)
1322 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1324 mGetErrorResult = GL_INVALID_OPERATION;
1330 inline void Uniform1i(GLint location, GLint x) override
1332 std::string params = std::to_string(x);
1334 AddUniformCallToTraceStack(location, params);
1336 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1338 mGetErrorResult = GL_INVALID_OPERATION;
1342 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1344 std::ostringstream out;
1345 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1346 AddUniformCallToTraceStack(location, out.str());
1348 for(int i = 0; i < count; ++i)
1350 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1354 mGetErrorResult = GL_INVALID_OPERATION;
1360 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1362 std::string params = std::to_string(x) + "," + std::to_string(y);
1363 AddUniformCallToTraceStack(location, params);
1365 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1369 mGetErrorResult = GL_INVALID_OPERATION;
1373 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1375 std::ostringstream out;
1376 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1377 AddUniformCallToTraceStack(location, out.str());
1379 for(int i = 0; i < count; ++i)
1381 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1383 Vector2(v[2 * i], v[2 * i + 1])))
1385 mGetErrorResult = GL_INVALID_OPERATION;
1391 inline void Uniform2i(GLint location, GLint x, GLint y) override
1393 std::string params = std::to_string(x) + "," + std::to_string(y);
1394 AddUniformCallToTraceStack(location, params);
1397 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1399 std::ostringstream out;
1400 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1401 AddUniformCallToTraceStack(location, out.str());
1404 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1406 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1407 AddUniformCallToTraceStack(location, params);
1409 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1413 mGetErrorResult = GL_INVALID_OPERATION;
1417 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1419 std::ostringstream out;
1420 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1421 AddUniformCallToTraceStack(location, out.str());
1423 for(int i = 0; i < count; ++i)
1425 if(!mProgramUniforms3f.SetUniformValue(
1428 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1430 mGetErrorResult = GL_INVALID_OPERATION;
1436 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1438 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1439 AddUniformCallToTraceStack(location, params);
1442 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1444 std::ostringstream out;
1445 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1446 AddUniformCallToTraceStack(location, out.str());
1449 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1451 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1452 AddUniformCallToTraceStack(location, params);
1454 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1456 Vector4(x, y, z, w)))
1458 mGetErrorResult = GL_INVALID_OPERATION;
1462 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1464 std::ostringstream out;
1465 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1466 AddUniformCallToTraceStack(location, out.str());
1468 for(int i = 0; i < count; ++i)
1470 if(!mProgramUniforms4f.SetUniformValue(
1473 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1475 mGetErrorResult = GL_INVALID_OPERATION;
1481 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1483 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1484 AddUniformCallToTraceStack(location, params);
1487 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1489 std::ostringstream out;
1490 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1491 AddUniformCallToTraceStack(location, out.str());
1494 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1496 std::ostringstream out;
1497 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1498 AddUniformCallToTraceStack(location, out.str());
1501 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1503 std::ostringstream out;
1504 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1505 AddUniformCallToTraceStack(location, out.str());
1507 for(int i = 0; i < count; ++i)
1509 if(!mProgramUniformsMat3.SetUniformValue(
1512 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1514 mGetErrorResult = GL_INVALID_OPERATION;
1520 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1522 std::ostringstream out;
1523 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1524 AddUniformCallToTraceStack(location, out.str());
1526 for(int i = 0; i < count; ++i)
1528 if(!mProgramUniformsMat4.SetUniformValue(
1533 mGetErrorResult = GL_INVALID_OPERATION;
1539 inline void UseProgram(GLuint program) override
1541 mCurrentProgram = program;
1544 inline void ValidateProgram(GLuint program) override
1548 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1552 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1556 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1560 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1564 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1568 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1572 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1576 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1580 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1582 TraceCallStack::NamedParams namedParams;
1583 namedParams["index"] << index;
1584 namedParams["size"] << size;
1585 namedParams["type"] << std::hex << type;
1586 namedParams["normalized"] << (normalized ? "T" : "F");
1587 namedParams["stride"] << stride;
1588 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1590 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1593 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1595 std::string commaString(", ");
1596 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1598 mViewportTrace.PushCall("Viewport", params);
1603 inline void ReadBuffer(GLenum mode) override
1607 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1611 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
1615 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
1619 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1623 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1627 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
1631 inline void GenQueries(GLsizei n, GLuint* ids) override
1635 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1639 inline GLboolean IsQuery(GLuint id) override
1644 inline void BeginQuery(GLenum target, GLuint id) override
1648 inline void EndQuery(GLenum target) override
1652 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1656 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1660 inline GLboolean UnmapBuffer(GLenum target) override
1664 free(mMappedBuffer);
1665 mMappedBuffer = nullptr;
1667 return true; // false indicates corruption, nothing else.
1670 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1674 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1678 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1682 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1686 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1690 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1694 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1698 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1702 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1706 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1710 inline void FramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) override
1712 // TODO : Check it if need
1713 FramebufferTexture2D(target, attachment, textarget, texture, level);
1716 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1720 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1722 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1723 return mMappedBuffer;
1726 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1730 inline void BindVertexArray(GLuint array) override
1734 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1738 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1742 inline GLboolean IsVertexArray(GLuint array) override
1747 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1751 inline void BeginTransformFeedback(GLenum primitiveMode) override
1755 inline void EndTransformFeedback(void) override
1759 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1763 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1767 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1771 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1775 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1779 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1783 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1787 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1791 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1795 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1799 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1803 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1807 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1812 inline void Uniform1ui(GLint location, GLuint v0) override
1816 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1820 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1824 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1828 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1832 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1836 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1840 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1844 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1848 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1852 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1856 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1860 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1865 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1869 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1873 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1877 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1879 return GL_INVALID_INDEX;
1882 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1886 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1890 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1894 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1898 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1902 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1907 inline GLboolean IsSync(GLsync sync) override
1912 inline void DeleteSync(GLsync sync) override
1916 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1921 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1925 inline void GetInteger64v(GLenum pname, GLint64* params) override
1929 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1933 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1937 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1941 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1945 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1949 inline GLboolean IsSampler(GLuint sampler) override
1954 inline void BindSampler(GLuint unit, GLuint sampler) override
1958 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1962 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1966 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1970 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1974 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1978 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1982 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1986 inline void BindTransformFeedback(GLenum target, GLuint id) override
1990 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1994 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1998 inline GLboolean IsTransformFeedback(GLuint id) override
2003 inline void PauseTransformFeedback(void) override
2007 inline void ResumeTransformFeedback(void) override
2011 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2013 mGetProgramBinaryCalled = true;
2016 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2020 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2024 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2028 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2032 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2036 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2040 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2044 inline void BlendBarrier(void)
2049 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2051 std::string name = "<not found>";
2052 bool matched = false;
2054 UniformIDMap& map = mUniforms[mCurrentProgram];
2055 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2057 if(it->second == location)
2067 mSetUniformTrace.PushCall(name, value);
2071 public: // TEST FUNCTIONS
2072 inline void SetCompileStatus(GLuint value)
2074 mCompileStatus = value;
2076 inline void SetLinkStatus(GLuint value)
2078 mLinkStatus = value;
2080 inline void SetAttribLocations(std::vector<std::string> locs)
2084 inline void SetGetErrorResult(GLenum result)
2086 mGetErrorResult = result;
2088 inline void SetGetStringResult(GLubyte* result)
2090 mGetStringResult = result;
2092 inline void SetIsBufferResult(GLboolean result)
2094 mIsBufferResult = result;
2096 inline void SetIsEnabledResult(GLboolean result)
2098 mIsEnabledResult = result;
2100 inline void SetIsFramebufferResult(GLboolean result)
2102 mIsFramebufferResult = result;
2104 inline void SetIsProgramResult(GLboolean result)
2106 mIsProgramResult = result;
2108 inline void SetIsRenderbufferResult(GLboolean result)
2110 mIsRenderbufferResult = result;
2112 inline void SetIsShaderResult(GLboolean result)
2114 mIsShaderResult = result;
2116 inline void SetIsTextureResult(GLboolean result)
2118 mIsTextureResult = result;
2120 inline void SetCheckFramebufferStatusResult(GLenum result)
2122 mCheckFramebufferStatusResult = result;
2124 inline void SetNumBinaryFormats(GLint numFormats)
2126 mNumBinaryFormats = numFormats;
2128 inline void SetBinaryFormats(GLint binaryFormats)
2130 mBinaryFormats = binaryFormats;
2132 inline void SetProgramBinaryLength(GLint length)
2134 mProgramBinaryLength = length;
2137 inline bool GetVertexAttribArrayState(GLuint index)
2139 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2144 return mVertexAttribArrayState[index];
2146 inline void ClearVertexAttribArrayChanged()
2148 mVertexAttribArrayChanged = false;
2150 inline bool GetVertexAttribArrayChanged()
2152 return mVertexAttribArrayChanged;
2155 //Methods for CullFace verification
2156 inline void EnableCullFaceCallTrace(bool enable)
2158 mCullFaceTrace.Enable(enable);
2160 inline void ResetCullFaceCallStack()
2162 mCullFaceTrace.Reset();
2164 inline TraceCallStack& GetCullFaceTrace()
2166 return mCullFaceTrace;
2169 //Methods for Enable/Disable call verification
2170 inline void EnableEnableDisableCallTrace(bool enable)
2172 mEnableDisableTrace.Enable(enable);
2174 inline void ResetEnableDisableCallStack()
2176 mEnableDisableTrace.Reset();
2178 inline TraceCallStack& GetEnableDisableTrace()
2180 return mEnableDisableTrace;
2183 //Methods for Shader verification
2184 inline void EnableShaderCallTrace(bool enable)
2186 mShaderTrace.Enable(enable);
2188 inline void ResetShaderCallStack()
2190 mShaderTrace.Reset();
2192 inline TraceCallStack& GetShaderTrace()
2194 return mShaderTrace;
2197 //Methods for Texture verification
2198 inline void EnableTextureCallTrace(bool enable)
2200 mTextureTrace.Enable(enable);
2202 inline void ResetTextureCallStack()
2204 mTextureTrace.Reset();
2206 inline TraceCallStack& GetTextureTrace()
2208 return mTextureTrace;
2211 //Methods for Texture verification
2212 inline void EnableTexParameterCallTrace(bool enable)
2214 mTexParameterTrace.Enable(enable);
2216 inline void ResetTexParameterCallStack()
2218 mTexParameterTrace.Reset();
2220 inline TraceCallStack& GetTexParameterTrace()
2222 return mTexParameterTrace;
2225 //Methods for Draw verification
2226 inline void EnableDrawCallTrace(bool enable)
2228 mDrawTrace.Enable(enable);
2230 inline void ResetDrawCallStack()
2234 inline TraceCallStack& GetDrawTrace()
2239 //Methods for Depth function verification
2240 inline void EnableDepthFunctionCallTrace(bool enable)
2242 mDepthFunctionTrace.Enable(enable);
2244 inline void ResetDepthFunctionCallStack()
2246 mDepthFunctionTrace.Reset();
2248 inline TraceCallStack& GetDepthFunctionTrace()
2250 return mDepthFunctionTrace;
2253 //Methods for Stencil function verification
2254 inline void EnableStencilFunctionCallTrace(bool enable)
2256 mStencilFunctionTrace.Enable(enable);
2258 inline void ResetStencilFunctionCallStack()
2260 mStencilFunctionTrace.Reset();
2262 inline TraceCallStack& GetStencilFunctionTrace()
2264 return mStencilFunctionTrace;
2267 //Methods for Scissor verification
2268 inline void EnableScissorCallTrace(bool enable)
2270 mScissorTrace.Enable(enable);
2272 inline void ResetScissorCallStack()
2274 mScissorTrace.Reset();
2276 inline TraceCallStack& GetScissorTrace()
2278 return mScissorTrace;
2281 //Methods for Uniform function verification
2282 inline void EnableSetUniformCallTrace(bool enable)
2284 mSetUniformTrace.Enable(enable);
2286 inline void ResetSetUniformCallStack()
2288 mSetUniformTrace.Reset();
2290 inline TraceCallStack& GetSetUniformTrace()
2292 return mSetUniformTrace;
2295 //Methods for Viewport verification
2296 inline void EnableViewportCallTrace(bool enable)
2298 mViewportTrace.Enable(enable);
2300 inline void ResetViewportCallStack()
2302 mViewportTrace.Reset();
2304 inline TraceCallStack& GetViewportTrace()
2306 return mViewportTrace;
2308 inline TraceCallStack& GetBufferTrace()
2310 return mBufferTrace;
2313 template<typename T>
2314 inline bool GetUniformValue(const char* name, T& value) const
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);
2330 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2336 template<typename T>
2337 inline bool CheckUniformValue(const char* name, const T& value) const
2339 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2340 program_it != mUniforms.end();
2343 const UniformIDMap& uniformIDs = program_it->second;
2345 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2346 if(uniform_it != uniformIDs.end())
2348 // found one matching uniform name, lets check the value...
2349 GLuint programId = program_it->first;
2350 GLint uniformId = uniform_it->second;
2352 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2353 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2355 // the value matches
2361 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2362 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2363 program_it != mUniforms.end();
2366 const UniformIDMap& uniformIDs = program_it->second;
2368 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2369 if(uniform_it != uniformIDs.end())
2371 // found one matching uniform name, lets check the value...
2372 GLuint programId = program_it->first;
2373 GLint uniformId = uniform_it->second;
2375 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2377 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2379 std::stringstream out;
2380 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2381 fprintf(stderr, "%s\n", out.str().c_str());
2388 template<typename T>
2389 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2391 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2392 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2395 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2397 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2398 program_it != mUniforms.end();
2401 const UniformIDMap& uniformIDs = program_it->second;
2403 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2404 if(uniform_it != uniformIDs.end())
2406 programId = program_it->first;
2407 uniformId = uniform_it->second;
2414 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2416 mCustomUniformData = customUniformData;
2419 inline GLuint GetLastShaderCompiled() const
2421 return mLastShaderCompiled;
2424 inline GLuint GetLastProgramCreated() const
2426 return mLastProgramIdUsed;
2429 inline GLbitfield GetLastClearMask() const
2431 return mLastClearBitMask;
2436 ATTRIB_UNKNOWN = -1,
2441 ATTRIB_BONE_WEIGHTS,
2442 ATTRIB_BONE_INDICES,
2446 struct ScissorParams
2462 // Methods to check scissor tests
2463 inline const ScissorParams& GetScissorParams() const
2465 return mScissorParams;
2468 struct ColorMaskParams
2484 inline bool GetProgramBinaryCalled() const
2486 return mGetProgramBinaryCalled;
2489 inline unsigned int GetClearCountCalled() const
2494 inline const ColorMaskParams& GetColorMaskParams() const
2496 return mColorMaskParams;
2499 typedef std::vector<size_t> BufferDataCalls;
2500 inline const BufferDataCalls& GetBufferDataCalls() const
2502 return mBufferDataCalls;
2504 inline void ResetBufferDataCalls()
2506 mBufferDataCalls.clear();
2509 typedef std::vector<size_t> BufferSubDataCalls;
2510 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2512 return mBufferSubDataCalls;
2514 inline void ResetBufferSubDataCalls()
2516 mBufferSubDataCalls.clear();
2520 GLuint mCurrentProgram;
2521 GLuint mCompileStatus;
2522 BufferDataCalls mBufferDataCalls;
2523 BufferSubDataCalls mBufferSubDataCalls;
2524 GLvoid* mMappedBuffer{nullptr};
2526 GLenum mGetErrorResult;
2527 GLubyte* mGetStringResult;
2528 GLboolean mIsBufferResult;
2529 GLboolean mIsEnabledResult;
2530 GLboolean mIsFramebufferResult;
2531 GLboolean mIsProgramResult;
2532 GLboolean mIsRenderbufferResult;
2533 GLboolean mIsShaderResult;
2534 GLboolean mIsTextureResult;
2535 GLenum mActiveTextureUnit;
2536 GLenum mCheckFramebufferStatusResult;
2537 GLint mFramebufferStatus;
2538 GLenum mFramebufferDepthAttached;
2539 GLenum mFramebufferStencilAttached;
2540 GLenum mFramebufferDepthStencilAttached;
2541 GLuint mFramebufferColorAttachmentCount;
2542 GLuint mFrameBufferColorStatus;
2543 GLuint mFramebufferDepthAttachmentCount;
2544 GLuint mFramebufferStencilAttachmentCount;
2545 GLuint mFramebufferDepthStencilAttachmentCount;
2546 GLint mNumBinaryFormats;
2547 GLint mBinaryFormats;
2548 GLint mProgramBinaryLength;
2549 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2550 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2551 bool mGetProgramBinaryCalled;
2552 typedef std::map<GLuint, std::string> ShaderSourceMap;
2553 ShaderSourceMap mShaderSources;
2554 std::vector<std::string> mAttribLocs; // should be bound to shader
2555 GLuint mLastShaderCompiled;
2556 GLbitfield mLastClearBitMask;
2557 Vector4 mLastClearColor;
2558 unsigned int mClearCount;
2560 Vector4 mLastBlendColor;
2561 GLenum mLastBlendEquationRgb;
2562 GLenum mLastBlendEquationAlpha;
2563 GLenum mLastBlendFuncSrcRgb;
2564 GLenum mLastBlendFuncDstRgb;
2565 GLenum mLastBlendFuncSrcAlpha;
2566 GLenum mLastBlendFuncDstAlpha;
2568 GLboolean mLastDepthMask;
2570 // Data for manipulating the IDs returned by GenTextures
2571 GLuint mLastAutoTextureIdUsed;
2572 GLuint mNumGeneratedTextures;
2573 std::vector<GLuint> mNextTextureIds;
2574 std::vector<GLuint> mDeletedTextureIds;
2575 std::vector<GLuint> mBoundTextures;
2577 struct ActiveTextureType
2579 std::vector<GLuint> mBoundTextures;
2582 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2584 TraceCallStack mBufferTrace;
2585 TraceCallStack mCullFaceTrace;
2586 TraceCallStack mEnableDisableTrace;
2587 TraceCallStack mShaderTrace;
2588 TraceCallStack mTextureTrace;
2589 TraceCallStack mTexParameterTrace;
2590 TraceCallStack mDrawTrace;
2591 TraceCallStack mDepthFunctionTrace;
2592 TraceCallStack mStencilFunctionTrace;
2593 TraceCallStack mScissorTrace;
2594 TraceCallStack mSetUniformTrace;
2595 TraceCallStack mViewportTrace;
2597 // Shaders & Uniforms
2598 GLuint mLastShaderIdUsed;
2599 GLuint mLastProgramIdUsed{0u};
2600 GLuint mLastUniformIdUsed;
2601 typedef std::map<std::string, GLint> UniformIDMap;
2602 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2603 ProgramUniformMap mUniforms;
2604 std::vector<ActiveUniform> mActiveUniforms;
2605 std::vector<UniformData> mCustomUniformData{};
2607 template<typename T>
2608 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2611 typedef std::map<GLint, T> UniformValueMap;
2612 typedef std::map<GLuint, UniformValueMap> Map;
2614 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2621 typename Map::iterator it = Map::find(program);
2622 if(it == Map::end())
2624 // if its the first uniform for this program add it
2625 std::pair<typename Map::iterator, bool> result =
2626 Map::insert(typename Map::value_type(program, UniformValueMap()));
2630 UniformValueMap& uniforms = it->second;
2631 uniforms[uniform] = value;
2636 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2639 if(GetUniformValue(program, uniform, uniformValue))
2641 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2647 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2654 typename Map::const_iterator it = Map::find(program);
2655 if(it == Map::end())
2657 // Uniform values always initialised as 0
2662 const UniformValueMap& uniforms = it->second;
2663 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2664 if(it2 == uniforms.end())
2666 // Uniform values always initialised as 0
2670 value = it2->second;
2677 ProgramUniformValue<int> mProgramUniforms1i;
2678 ProgramUniformValue<float> mProgramUniforms1f;
2679 ProgramUniformValue<Vector2> mProgramUniforms2f;
2680 ProgramUniformValue<Vector3> mProgramUniforms3f;
2681 ProgramUniformValue<Vector4> mProgramUniforms4f;
2682 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2683 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2685 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2687 return mProgramUniforms1i;
2689 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2691 return mProgramUniforms1f;
2693 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2695 return mProgramUniforms2f;
2697 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2699 return mProgramUniforms3f;
2701 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2703 return mProgramUniforms4f;
2705 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2707 return mProgramUniformsMat4;
2709 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2711 return mProgramUniformsMat3;
2713 inline void SetVertexAttribArray(GLuint index, bool state)
2715 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2720 mVertexAttribArrayState[index] = state;
2721 mVertexAttribArrayChanged = true;
2724 ScissorParams mScissorParams;
2725 ColorMaskParams mColorMaskParams;
2729 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2735 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2741 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2743 return Vector2::ZERO;
2747 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2749 return Vector3::ZERO;
2753 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2755 return Vector4::ZERO;
2759 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2765 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2767 return Matrix3(Matrix());
2772 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2773 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2775 #endif // TEST_GL_ABSTRACTION_H