1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2023 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
1896 std::stringstream out;
1897 out << mode << ", " << first << ", " << count << ", " << instanceCount;
1898 TraceCallStack::NamedParams namedParams;
1899 namedParams["mode"] << std::hex << mode;
1900 namedParams["first"] << first;
1901 namedParams["count"] << count;
1902 namedParams["instanceCount"] << instanceCount;
1903 mDrawTrace.PushCall("DrawArraysInstanced", out.str(), namedParams);
1906 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1908 std::stringstream out;
1909 out << mode << ", " << count << ", " << type << ", " << instanceCount;
1910 TraceCallStack::NamedParams namedParams;
1911 namedParams["mode"] << std::hex << mode;
1912 namedParams["count"] << count;
1913 namedParams["type"] << std::hex << type;
1914 namedParams["indexCount"] << instanceCount;
1915 mDrawTrace.PushCall("DrawElementsInstanced", out.str(), namedParams);
1918 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1923 inline GLboolean IsSync(GLsync sync) override
1928 inline void DeleteSync(GLsync sync) override
1932 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1937 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1941 inline void GetInteger64v(GLenum pname, GLint64* params) override
1945 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1949 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1953 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1957 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1961 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1965 inline GLboolean IsSampler(GLuint sampler) override
1970 inline void BindSampler(GLuint unit, GLuint sampler) override
1974 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1978 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1982 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1986 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1990 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1994 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1998 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
2000 std::stringstream out;
2001 out << index << ", " << divisor;
2002 TraceCallStack::NamedParams namedParams;
2003 namedParams["index"] << index;
2004 namedParams["divisor"] << divisor;
2005 mBufferTrace.PushCall("VertexAttribDivisor", out.str(), namedParams);
2008 inline void BindTransformFeedback(GLenum target, GLuint id) override
2012 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
2016 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
2020 inline GLboolean IsTransformFeedback(GLuint id) override
2025 inline void PauseTransformFeedback(void) override
2029 inline void ResumeTransformFeedback(void) override
2033 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2035 mGetProgramBinaryCalled = true;
2038 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2042 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2046 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2050 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2054 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2058 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2062 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2066 inline void BlendBarrier(void)
2071 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2073 std::string name = "<not found>";
2074 bool matched = false;
2076 UniformIDMap& map = mUniforms[mCurrentProgram];
2077 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2079 if(it->second == location)
2089 mSetUniformTrace.PushCall(name, value);
2093 public: // TEST FUNCTIONS
2094 inline void SetCompileStatus(GLuint value)
2096 mCompileStatus = value;
2098 inline void SetLinkStatus(GLuint value)
2100 mLinkStatus = value;
2102 inline void SetAttribLocations(std::vector<std::string> locs)
2106 inline void SetGetErrorResult(GLenum result)
2108 mGetErrorResult = result;
2110 inline void SetGetStringResult(GLubyte* result)
2112 mGetStringResult = result;
2114 inline void SetIsBufferResult(GLboolean result)
2116 mIsBufferResult = result;
2118 inline void SetIsEnabledResult(GLboolean result)
2120 mIsEnabledResult = result;
2122 inline void SetIsFramebufferResult(GLboolean result)
2124 mIsFramebufferResult = result;
2126 inline void SetIsProgramResult(GLboolean result)
2128 mIsProgramResult = result;
2130 inline void SetIsRenderbufferResult(GLboolean result)
2132 mIsRenderbufferResult = result;
2134 inline void SetIsShaderResult(GLboolean result)
2136 mIsShaderResult = result;
2138 inline void SetIsTextureResult(GLboolean result)
2140 mIsTextureResult = result;
2142 inline void SetCheckFramebufferStatusResult(GLenum result)
2144 mCheckFramebufferStatusResult = result;
2146 inline void SetNumBinaryFormats(GLint numFormats)
2148 mNumBinaryFormats = numFormats;
2150 inline void SetBinaryFormats(GLint binaryFormats)
2152 mBinaryFormats = binaryFormats;
2154 inline void SetProgramBinaryLength(GLint length)
2156 mProgramBinaryLength = length;
2159 inline bool GetVertexAttribArrayState(GLuint index)
2161 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2166 return mVertexAttribArrayState[index];
2168 inline void ClearVertexAttribArrayChanged()
2170 mVertexAttribArrayChanged = false;
2172 inline bool GetVertexAttribArrayChanged()
2174 return mVertexAttribArrayChanged;
2177 //Methods for CullFace verification
2178 inline void EnableCullFaceCallTrace(bool enable)
2180 mCullFaceTrace.Enable(enable);
2182 inline void ResetCullFaceCallStack()
2184 mCullFaceTrace.Reset();
2186 inline TraceCallStack& GetCullFaceTrace()
2188 return mCullFaceTrace;
2191 //Methods for Enable/Disable call verification
2192 inline void EnableEnableDisableCallTrace(bool enable)
2194 mEnableDisableTrace.Enable(enable);
2196 inline void ResetEnableDisableCallStack()
2198 mEnableDisableTrace.Reset();
2200 inline TraceCallStack& GetEnableDisableTrace()
2202 return mEnableDisableTrace;
2205 //Methods for Shader verification
2206 inline void EnableShaderCallTrace(bool enable)
2208 mShaderTrace.Enable(enable);
2210 inline void ResetShaderCallStack()
2212 mShaderTrace.Reset();
2214 inline TraceCallStack& GetShaderTrace()
2216 return mShaderTrace;
2219 //Methods for Texture verification
2220 inline void EnableTextureCallTrace(bool enable)
2222 mTextureTrace.Enable(enable);
2224 inline void ResetTextureCallStack()
2226 mTextureTrace.Reset();
2228 inline TraceCallStack& GetTextureTrace()
2230 return mTextureTrace;
2233 //Methods for Texture verification
2234 inline void EnableTexParameterCallTrace(bool enable)
2236 mTexParameterTrace.Enable(enable);
2238 inline void ResetTexParameterCallStack()
2240 mTexParameterTrace.Reset();
2242 inline TraceCallStack& GetTexParameterTrace()
2244 return mTexParameterTrace;
2247 //Methods for Draw verification
2248 inline void EnableDrawCallTrace(bool enable)
2250 mDrawTrace.Enable(enable);
2252 inline void ResetDrawCallStack()
2256 inline TraceCallStack& GetDrawTrace()
2261 //Methods for Depth function verification
2262 inline void EnableDepthFunctionCallTrace(bool enable)
2264 mDepthFunctionTrace.Enable(enable);
2266 inline void ResetDepthFunctionCallStack()
2268 mDepthFunctionTrace.Reset();
2270 inline TraceCallStack& GetDepthFunctionTrace()
2272 return mDepthFunctionTrace;
2275 //Methods for Stencil function verification
2276 inline void EnableStencilFunctionCallTrace(bool enable)
2278 mStencilFunctionTrace.Enable(enable);
2280 inline void ResetStencilFunctionCallStack()
2282 mStencilFunctionTrace.Reset();
2284 inline TraceCallStack& GetStencilFunctionTrace()
2286 return mStencilFunctionTrace;
2289 //Methods for Scissor verification
2290 inline void EnableScissorCallTrace(bool enable)
2292 mScissorTrace.Enable(enable);
2294 inline void ResetScissorCallStack()
2296 mScissorTrace.Reset();
2298 inline TraceCallStack& GetScissorTrace()
2300 return mScissorTrace;
2303 //Methods for Uniform function verification
2304 inline void EnableSetUniformCallTrace(bool enable)
2306 mSetUniformTrace.Enable(enable);
2308 inline void ResetSetUniformCallStack()
2310 mSetUniformTrace.Reset();
2312 inline TraceCallStack& GetSetUniformTrace()
2314 return mSetUniformTrace;
2317 //Methods for Viewport verification
2318 inline void EnableViewportCallTrace(bool enable)
2320 mViewportTrace.Enable(enable);
2322 inline void ResetViewportCallStack()
2324 mViewportTrace.Reset();
2326 inline TraceCallStack& GetViewportTrace()
2328 return mViewportTrace;
2330 inline TraceCallStack& GetBufferTrace()
2332 return mBufferTrace;
2335 template<typename T>
2336 inline bool GetUniformValue(const char* name, T& value) const
2338 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2339 program_it != mUniforms.end();
2342 const UniformIDMap& uniformIDs = program_it->second;
2344 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2345 if(uniform_it != uniformIDs.end())
2347 // found one matching uniform name, lets check the value...
2348 GLuint programId = program_it->first;
2349 GLint uniformId = uniform_it->second;
2351 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2352 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2358 template<typename T>
2359 inline bool CheckUniformValue(const char* name, const T& value) const
2361 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2362 program_it != mUniforms.end();
2365 const UniformIDMap& uniformIDs = program_it->second;
2367 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2368 if(uniform_it != uniformIDs.end())
2370 // found one matching uniform name, lets check the value...
2371 GLuint programId = program_it->first;
2372 GLint uniformId = uniform_it->second;
2374 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2375 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2377 // the value matches
2383 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2384 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2385 program_it != mUniforms.end();
2388 const UniformIDMap& uniformIDs = program_it->second;
2390 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2391 if(uniform_it != uniformIDs.end())
2393 // found one matching uniform name, lets check the value...
2394 GLuint programId = program_it->first;
2395 GLint uniformId = uniform_it->second;
2397 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2399 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2401 std::stringstream out;
2402 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2403 fprintf(stderr, "%s\n", out.str().c_str());
2410 template<typename T>
2411 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2413 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2414 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2417 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2419 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2420 program_it != mUniforms.end();
2423 const UniformIDMap& uniformIDs = program_it->second;
2425 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2426 if(uniform_it != uniformIDs.end())
2428 programId = program_it->first;
2429 uniformId = uniform_it->second;
2436 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2438 mCustomUniformData = customUniformData;
2441 inline GLuint GetLastShaderCompiled() const
2443 return mLastShaderCompiled;
2446 inline GLuint GetLastProgramCreated() const
2448 return mLastProgramIdUsed;
2451 inline GLbitfield GetLastClearMask() const
2453 return mLastClearBitMask;
2458 ATTRIB_UNKNOWN = -1,
2463 ATTRIB_BONE_WEIGHTS,
2464 ATTRIB_BONE_INDICES,
2468 struct ScissorParams
2484 // Methods to check scissor tests
2485 inline const ScissorParams& GetScissorParams() const
2487 return mScissorParams;
2490 struct ColorMaskParams
2506 inline bool GetProgramBinaryCalled() const
2508 return mGetProgramBinaryCalled;
2511 inline unsigned int GetClearCountCalled() const
2516 inline const ColorMaskParams& GetColorMaskParams() const
2518 return mColorMaskParams;
2521 typedef std::vector<size_t> BufferDataCalls;
2522 inline const BufferDataCalls& GetBufferDataCalls() const
2524 return mBufferDataCalls;
2526 inline void ResetBufferDataCalls()
2528 mBufferDataCalls.clear();
2531 typedef std::vector<size_t> BufferSubDataCalls;
2532 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2534 return mBufferSubDataCalls;
2536 inline void ResetBufferSubDataCalls()
2538 mBufferSubDataCalls.clear();
2542 GLuint mCurrentProgram;
2543 GLuint mCompileStatus;
2544 BufferDataCalls mBufferDataCalls;
2545 BufferSubDataCalls mBufferSubDataCalls;
2546 GLvoid* mMappedBuffer{nullptr};
2548 GLenum mGetErrorResult;
2549 GLubyte* mGetStringResult;
2550 GLboolean mIsBufferResult;
2551 GLboolean mIsEnabledResult;
2552 GLboolean mIsFramebufferResult;
2553 GLboolean mIsProgramResult;
2554 GLboolean mIsRenderbufferResult;
2555 GLboolean mIsShaderResult;
2556 GLboolean mIsTextureResult;
2557 GLenum mActiveTextureUnit;
2558 GLenum mCheckFramebufferStatusResult;
2559 GLint mFramebufferStatus;
2560 GLenum mFramebufferDepthAttached;
2561 GLenum mFramebufferStencilAttached;
2562 GLenum mFramebufferDepthStencilAttached;
2563 GLuint mFramebufferColorAttachmentCount;
2564 GLuint mFrameBufferColorStatus;
2565 GLuint mFramebufferDepthAttachmentCount;
2566 GLuint mFramebufferStencilAttachmentCount;
2567 GLuint mFramebufferDepthStencilAttachmentCount;
2568 GLint mNumBinaryFormats;
2569 GLint mBinaryFormats;
2570 GLint mProgramBinaryLength;
2571 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2572 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2573 bool mGetProgramBinaryCalled;
2574 typedef std::map<GLuint, std::string> ShaderSourceMap;
2575 ShaderSourceMap mShaderSources;
2576 std::vector<std::string> mAttribLocs; // should be bound to shader
2577 GLuint mLastShaderCompiled;
2578 GLbitfield mLastClearBitMask;
2579 Vector4 mLastClearColor;
2580 unsigned int mClearCount;
2582 Vector4 mLastBlendColor;
2583 GLenum mLastBlendEquationRgb;
2584 GLenum mLastBlendEquationAlpha;
2585 GLenum mLastBlendFuncSrcRgb;
2586 GLenum mLastBlendFuncDstRgb;
2587 GLenum mLastBlendFuncSrcAlpha;
2588 GLenum mLastBlendFuncDstAlpha;
2590 GLboolean mLastDepthMask;
2592 // Data for manipulating the IDs returned by GenTextures
2593 GLuint mLastAutoTextureIdUsed;
2594 GLuint mNumGeneratedTextures;
2595 std::vector<GLuint> mNextTextureIds;
2596 std::vector<GLuint> mDeletedTextureIds;
2597 std::vector<GLuint> mBoundTextures;
2599 struct ActiveTextureType
2601 std::vector<GLuint> mBoundTextures;
2604 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2606 TraceCallStack mBufferTrace;
2607 TraceCallStack mCullFaceTrace;
2608 TraceCallStack mEnableDisableTrace;
2609 TraceCallStack mShaderTrace;
2610 TraceCallStack mTextureTrace;
2611 TraceCallStack mTexParameterTrace;
2612 TraceCallStack mDrawTrace;
2613 TraceCallStack mDepthFunctionTrace;
2614 TraceCallStack mStencilFunctionTrace;
2615 TraceCallStack mScissorTrace;
2616 TraceCallStack mSetUniformTrace;
2617 TraceCallStack mViewportTrace;
2619 // Shaders & Uniforms
2620 GLuint mLastShaderIdUsed;
2621 GLuint mLastProgramIdUsed{0u};
2622 GLuint mLastUniformIdUsed;
2623 typedef std::map<std::string, GLint> UniformIDMap;
2624 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2625 ProgramUniformMap mUniforms;
2626 std::vector<ActiveUniform> mActiveUniforms;
2627 std::vector<UniformData> mCustomUniformData{};
2629 template<typename T>
2630 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2633 typedef std::map<GLint, T> UniformValueMap;
2634 typedef std::map<GLuint, UniformValueMap> Map;
2636 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2643 typename Map::iterator it = Map::find(program);
2644 if(it == Map::end())
2646 // if its the first uniform for this program add it
2647 std::pair<typename Map::iterator, bool> result =
2648 Map::insert(typename Map::value_type(program, UniformValueMap()));
2652 UniformValueMap& uniforms = it->second;
2653 uniforms[uniform] = value;
2658 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2661 if(GetUniformValue(program, uniform, uniformValue))
2663 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2669 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2676 typename Map::const_iterator it = Map::find(program);
2677 if(it == Map::end())
2679 // Uniform values always initialised as 0
2684 const UniformValueMap& uniforms = it->second;
2685 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2686 if(it2 == uniforms.end())
2688 // Uniform values always initialised as 0
2692 value = it2->second;
2699 ProgramUniformValue<int> mProgramUniforms1i;
2700 ProgramUniformValue<float> mProgramUniforms1f;
2701 ProgramUniformValue<Vector2> mProgramUniforms2f;
2702 ProgramUniformValue<Vector3> mProgramUniforms3f;
2703 ProgramUniformValue<Vector4> mProgramUniforms4f;
2704 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2705 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2707 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2709 return mProgramUniforms1i;
2711 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2713 return mProgramUniforms1f;
2715 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2717 return mProgramUniforms2f;
2719 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2721 return mProgramUniforms3f;
2723 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2725 return mProgramUniforms4f;
2727 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2729 return mProgramUniformsMat4;
2731 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2733 return mProgramUniformsMat3;
2735 inline void SetVertexAttribArray(GLuint index, bool state)
2737 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2742 mVertexAttribArrayState[index] = state;
2743 mVertexAttribArrayChanged = true;
2746 ScissorParams mScissorParams;
2747 ColorMaskParams mColorMaskParams;
2751 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2757 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2763 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2765 return Vector2::ZERO;
2769 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2771 return Vector3::ZERO;
2775 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2777 return Vector4::ZERO;
2781 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2787 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2789 return Matrix3(Matrix());
2794 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2795 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2797 #endif // TEST_GL_ABSTRACTION_H