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
799 strncpy(name, mAttribLocs[index].c_str(), 99);
800 *type = mAttribTypes[index];
803 inline void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms)
805 mActiveUniforms = uniforms;
808 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
810 if(index < mActiveUniforms.size())
812 *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
813 *type = mActiveUniforms[index].type;
814 *size = mActiveUniforms[index].size;
818 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
822 inline int GetAttribLocation(GLuint program, const char* name) override
824 std::string check(name);
825 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
826 if(iter == mAttribLocs.end())
828 return iter - mAttribLocs.begin();
831 inline void GetBooleanv(GLenum pname, GLboolean* params) override
835 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
839 inline GLenum GetError(void) override
841 return mGetErrorResult;
844 inline void GetFloatv(GLenum pname, GLfloat* params) override
848 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
852 inline void GetIntegerv(GLenum pname, GLint* params) override
856 case GL_MAX_TEXTURE_SIZE:
859 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
862 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
863 *params = mNumBinaryFormats;
865 case GL_PROGRAM_BINARY_FORMATS_OES:
866 *params = mBinaryFormats;
871 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
876 *params = mLinkStatus;
878 case GL_PROGRAM_BINARY_LENGTH_OES:
879 *params = mProgramBinaryLength;
881 case GL_ACTIVE_UNIFORMS:
882 *params = mActiveUniforms.size();
884 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
887 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
890 case GL_ACTIVE_ATTRIBUTES:
891 *params = static_cast<GLint>(mAttribLocs.size());
896 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
900 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
904 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
908 case GL_COMPILE_STATUS:
909 *params = mCompileStatus;
914 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
918 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
922 inline const GLubyte* GetString(GLenum name) override
924 return mGetStringResult;
927 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
931 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
935 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
939 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
943 inline GLint GetUniformLocation(GLuint program, const char* name) override
945 ProgramUniformMap::iterator it = mUniforms.find(program);
946 if(it == mUniforms.end())
948 // Not a valid program ID
949 mGetErrorResult = GL_INVALID_OPERATION;
953 UniformIDMap& uniformIDs = it->second;
954 UniformIDMap::iterator it2 = uniformIDs.find(name);
955 if(it2 == uniformIDs.end())
957 // Uniform not found, so add it...
958 uniformIDs[name] = ++mLastUniformIdUsed;
959 return uniformIDs[name];
965 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
969 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
973 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
977 inline void Hint(GLenum target, GLenum mode) override
981 inline GLboolean IsBuffer(GLuint buffer) override
983 return mIsBufferResult;
986 inline GLboolean IsEnabled(GLenum cap) override
988 return mIsEnabledResult;
991 inline GLboolean IsFramebuffer(GLuint framebuffer) override
993 return mIsFramebufferResult;
996 inline GLboolean IsProgram(GLuint program) override
998 return mIsProgramResult;
1001 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
1003 return mIsRenderbufferResult;
1006 inline GLboolean IsShader(GLuint shader) override
1008 return mIsShaderResult;
1011 inline GLboolean IsTexture(GLuint texture) override
1013 return mIsTextureResult;
1016 inline void LineWidth(GLfloat width) override
1020 inline void LinkProgram(GLuint program) override
1022 std::stringstream out;
1025 TraceCallStack::NamedParams namedParams;
1026 namedParams["program"] << program;
1027 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
1029 for(const auto& uniform : mActiveUniforms)
1031 GetUniformLocation(program, uniform.name.c_str());
1034 for(const auto& uniform : mCustomUniformData)
1036 auto iter = uniform.name.find("[");
1037 auto name = uniform.name;
1038 if(iter != std::string::npos)
1040 name = uniform.name.substr(0, iter);
1041 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1042 iter = uniform.name.find("]");
1044 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1046 suffix = uniform.name.substr(iter + 1); // If there is a suffix, it means its an element of an array of struct
1049 for(int i = 0; i < arrayCount; ++i)
1051 std::stringstream nss;
1052 nss << name << "[" << i << "]" << suffix;
1053 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1058 GetUniformLocation(program, name.c_str());
1063 inline void PixelStorei(GLenum pname, GLint param) override
1067 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1071 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1075 inline void ReleaseShaderCompiler(void) override
1079 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1083 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1087 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1089 mScissorParams.x = x;
1090 mScissorParams.y = y;
1091 mScissorParams.width = width;
1092 mScissorParams.height = height;
1094 std::stringstream out;
1095 out << x << ", " << y << ", " << width << ", " << height;
1096 TraceCallStack::NamedParams namedParams;
1097 namedParams["x"] << x;
1098 namedParams["y"] << y;
1099 namedParams["width"] << width;
1100 namedParams["height"] << height;
1101 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1104 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1108 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1110 std::string stringBuilder;
1111 for(int i = 0; i < count; ++i)
1113 stringBuilder += string[i];
1115 mShaderSources[shader] = stringBuilder;
1116 mLastShaderCompiled = shader;
1119 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1121 const std::string shaderSource = mShaderSources[shader];
1122 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1123 if(shaderSourceLength < bufsize)
1125 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1126 *length = shaderSourceLength;
1130 *length = bufsize - 1;
1131 strncpy(source, shaderSource.c_str(), *length);
1132 source[*length] = 0x0;
1136 inline std::string GetShaderSource(GLuint shader)
1138 return mShaderSources[shader];
1141 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1143 std::stringstream out;
1144 out << func << ", " << ref << ", " << mask;
1146 TraceCallStack::NamedParams namedParams;
1147 namedParams["func"] << std::hex << func;
1148 namedParams["ref"] << ref;
1149 namedParams["mask"] << mask;
1151 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1154 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1156 std::stringstream out;
1157 out << face << ", " << func << ", " << ref << ", " << mask;
1159 TraceCallStack::NamedParams namedParams;
1160 namedParams["face"] << std::hex << face;
1161 namedParams["func"] << std::hex << func;
1162 namedParams["ref"] << ref;
1163 namedParams["mask"] << mask;
1165 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1168 inline void StencilMask(GLuint mask) override
1170 std::stringstream out;
1173 TraceCallStack::NamedParams namedParams;
1174 namedParams["mask"] << mask;
1176 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1179 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1181 std::stringstream out;
1182 out << face << ", " << mask;
1184 TraceCallStack::NamedParams namedParams;
1185 namedParams["face"] << std::hex << face;
1186 namedParams["mask"] << mask;
1188 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1191 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1193 std::stringstream out;
1194 out << fail << ", " << zfail << ", " << zpass;
1196 TraceCallStack::NamedParams namedParams;
1197 namedParams["fail"] << std::hex << fail;
1198 namedParams["zfail"] << std::hex << zfail;
1199 namedParams["zpass"] << std::hex << zpass;
1201 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1204 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1206 std::stringstream out;
1207 out << face << ", " << fail << ", " << zfail << "," << zpass;
1209 TraceCallStack::NamedParams namedParams;
1210 namedParams["face"] << std::hex << face;
1211 namedParams["fail"] << std::hex << fail;
1212 namedParams["zfail"] << std::hex << zfail;
1213 namedParams["zpass"] << std::hex << zpass;
1215 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1218 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1220 std::stringstream out;
1221 out << target << ", " << level << ", " << width << ", " << height;
1223 TraceCallStack::NamedParams namedParams;
1224 namedParams["target"] << std::hex << target;
1225 namedParams["level"] << level;
1226 namedParams["internalformat"] << internalformat;
1227 namedParams["width"] << width;
1228 namedParams["height"] << height;
1229 namedParams["border"] << border;
1230 namedParams["format"] << std::hex << format;
1231 namedParams["type"] << std::hex << type;
1233 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1236 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1238 std::stringstream out;
1239 out << target << ", " << pname << ", " << param;
1241 TraceCallStack::NamedParams namedParams;
1242 namedParams["target"] << std::hex << target;
1243 namedParams["pname"] << std::hex << pname;
1244 namedParams["param"] << param;
1246 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1249 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1251 std::stringstream out;
1252 out << target << ", " << pname << ", " << params[0];
1254 TraceCallStack::NamedParams namedParams;
1255 namedParams["target"] << std::hex << target;
1256 namedParams["pname"] << std::hex << pname;
1257 namedParams["params[0]"] << params[0];
1259 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1262 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1264 std::stringstream out;
1265 out << std::hex << target << ", " << pname << ", " << param;
1266 std::string params = out.str();
1268 TraceCallStack::NamedParams namedParams;
1269 namedParams["target"] << std::hex << target;
1270 namedParams["pname"] << std::hex << pname;
1271 namedParams["param"] << param;
1272 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1275 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1277 std::stringstream out;
1278 out << target << ", " << pname << ", " << params[0];
1279 TraceCallStack::NamedParams namedParams;
1280 namedParams["target"] << std::hex << target;
1281 namedParams["pname"] << std::hex << pname;
1282 namedParams["params[0]"] << params[0];
1283 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1286 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1288 std::stringstream out;
1289 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1291 TraceCallStack::NamedParams namedParams;
1292 namedParams["target"] << std::hex << target;
1293 namedParams["level"] << level;
1294 namedParams["xoffset"] << xoffset;
1295 namedParams["yoffset"] << yoffset;
1296 namedParams["width"] << width;
1297 namedParams["height"] << height;
1298 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1301 inline void Uniform1f(GLint location, GLfloat value) override
1303 std::string params = std::to_string(value);
1304 AddUniformCallToTraceStack(location, params);
1306 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1308 mGetErrorResult = GL_INVALID_OPERATION;
1312 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1315 for(int i = 0; i < count; ++i)
1317 params = params + std::to_string(v[i]) + ",";
1320 AddUniformCallToTraceStack(location, params);
1322 for(int i = 0; i < count; ++i)
1324 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1326 mGetErrorResult = GL_INVALID_OPERATION;
1332 inline void Uniform1i(GLint location, GLint x) override
1334 std::string params = std::to_string(x);
1336 AddUniformCallToTraceStack(location, params);
1338 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1340 mGetErrorResult = GL_INVALID_OPERATION;
1344 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1346 std::ostringstream out;
1347 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1348 AddUniformCallToTraceStack(location, out.str());
1350 for(int i = 0; i < count; ++i)
1352 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1356 mGetErrorResult = GL_INVALID_OPERATION;
1362 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1364 std::string params = std::to_string(x) + "," + std::to_string(y);
1365 AddUniformCallToTraceStack(location, params);
1367 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1371 mGetErrorResult = GL_INVALID_OPERATION;
1375 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1377 std::ostringstream out;
1378 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1379 AddUniformCallToTraceStack(location, out.str());
1381 for(int i = 0; i < count; ++i)
1383 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1385 Vector2(v[2 * i], v[2 * i + 1])))
1387 mGetErrorResult = GL_INVALID_OPERATION;
1393 inline void Uniform2i(GLint location, GLint x, GLint y) override
1395 std::string params = std::to_string(x) + "," + std::to_string(y);
1396 AddUniformCallToTraceStack(location, params);
1399 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1401 std::ostringstream out;
1402 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1403 AddUniformCallToTraceStack(location, out.str());
1406 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1408 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1409 AddUniformCallToTraceStack(location, params);
1411 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1415 mGetErrorResult = GL_INVALID_OPERATION;
1419 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1421 std::ostringstream out;
1422 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1423 AddUniformCallToTraceStack(location, out.str());
1425 for(int i = 0; i < count; ++i)
1427 if(!mProgramUniforms3f.SetUniformValue(
1430 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1432 mGetErrorResult = GL_INVALID_OPERATION;
1438 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1440 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1441 AddUniformCallToTraceStack(location, params);
1444 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1446 std::ostringstream out;
1447 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1448 AddUniformCallToTraceStack(location, out.str());
1451 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1453 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1454 AddUniformCallToTraceStack(location, params);
1456 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1458 Vector4(x, y, z, w)))
1460 mGetErrorResult = GL_INVALID_OPERATION;
1464 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1466 std::ostringstream out;
1467 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1468 AddUniformCallToTraceStack(location, out.str());
1470 for(int i = 0; i < count; ++i)
1472 if(!mProgramUniforms4f.SetUniformValue(
1475 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1477 mGetErrorResult = GL_INVALID_OPERATION;
1483 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1485 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1486 AddUniformCallToTraceStack(location, params);
1489 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1491 std::ostringstream out;
1492 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1493 AddUniformCallToTraceStack(location, out.str());
1496 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1498 std::ostringstream out;
1499 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1500 AddUniformCallToTraceStack(location, out.str());
1503 inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1505 std::ostringstream out;
1506 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1507 AddUniformCallToTraceStack(location, out.str());
1509 for(int i = 0; i < count; ++i)
1511 if(!mProgramUniformsMat3.SetUniformValue(
1514 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1516 mGetErrorResult = GL_INVALID_OPERATION;
1522 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1524 std::ostringstream out;
1525 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1526 AddUniformCallToTraceStack(location, out.str());
1528 for(int i = 0; i < count; ++i)
1530 if(!mProgramUniformsMat4.SetUniformValue(
1535 mGetErrorResult = GL_INVALID_OPERATION;
1541 inline void UseProgram(GLuint program) override
1543 mCurrentProgram = program;
1546 inline void ValidateProgram(GLuint program) override
1550 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1554 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1558 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1562 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1566 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1570 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1574 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1578 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1582 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1584 TraceCallStack::NamedParams namedParams;
1585 namedParams["index"] << index;
1586 namedParams["size"] << size;
1587 namedParams["type"] << std::hex << type;
1588 namedParams["normalized"] << (normalized ? "T" : "F");
1589 namedParams["stride"] << stride;
1590 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1592 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1595 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1597 TraceCallStack::NamedParams namedParams;
1598 namedParams["index"] << index;
1599 namedParams["size"] << size;
1600 namedParams["type"] << std::hex << type;
1601 namedParams["stride"] << stride;
1602 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(pointer));
1604 mBufferTrace.PushCall("VertexAttribIPointer", namedParams.str(), namedParams);
1607 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1609 std::string commaString(", ");
1610 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1612 mViewportTrace.PushCall("Viewport", params);
1617 inline void ReadBuffer(GLenum mode) override
1621 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1625 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
1629 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
1633 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1637 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1641 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
1645 inline void GenQueries(GLsizei n, GLuint* ids) override
1649 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1653 inline GLboolean IsQuery(GLuint id) override
1658 inline void BeginQuery(GLenum target, GLuint id) override
1662 inline void EndQuery(GLenum target) override
1666 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1670 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1674 inline GLboolean UnmapBuffer(GLenum target) override
1678 free(mMappedBuffer);
1679 mMappedBuffer = nullptr;
1681 return true; // false indicates corruption, nothing else.
1684 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1688 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1692 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1696 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1700 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1704 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1708 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1712 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1716 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1720 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1724 inline void FramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) override
1726 // TODO : Check it if need
1727 FramebufferTexture2D(target, attachment, textarget, texture, level);
1730 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1734 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1736 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1737 return mMappedBuffer;
1740 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1744 inline void BindVertexArray(GLuint array) override
1748 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1752 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1756 inline GLboolean IsVertexArray(GLuint array) override
1761 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1765 inline void BeginTransformFeedback(GLenum primitiveMode) override
1769 inline void EndTransformFeedback(void) override
1773 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1777 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1781 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1785 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1789 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1793 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1797 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1801 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1805 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1809 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1813 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1817 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1822 inline void Uniform1ui(GLint location, GLuint v0) override
1826 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1830 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1834 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1838 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1842 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1846 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1850 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1854 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1858 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1862 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1866 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1870 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1875 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1879 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1883 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1887 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1889 return GL_INVALID_INDEX;
1892 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1896 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1900 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1904 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1906 std::stringstream out;
1907 out << mode << ", " << first << ", " << count << ", " << instanceCount;
1908 TraceCallStack::NamedParams namedParams;
1909 namedParams["mode"] << std::hex << mode;
1910 namedParams["first"] << first;
1911 namedParams["count"] << count;
1912 namedParams["instanceCount"] << instanceCount;
1913 mDrawTrace.PushCall("DrawArraysInstanced", out.str(), namedParams);
1916 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1918 std::stringstream out;
1919 out << mode << ", " << count << ", " << type << ", " << instanceCount;
1920 TraceCallStack::NamedParams namedParams;
1921 namedParams["mode"] << std::hex << mode;
1922 namedParams["count"] << count;
1923 namedParams["type"] << std::hex << type;
1924 namedParams["indexCount"] << instanceCount;
1925 mDrawTrace.PushCall("DrawElementsInstanced", out.str(), namedParams);
1928 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1933 inline GLboolean IsSync(GLsync sync) override
1938 inline void DeleteSync(GLsync sync) override
1942 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1947 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1951 inline void GetInteger64v(GLenum pname, GLint64* params) override
1955 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1959 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1963 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1967 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1971 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1975 inline GLboolean IsSampler(GLuint sampler) override
1980 inline void BindSampler(GLuint unit, GLuint sampler) override
1984 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1988 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1992 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1996 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
2000 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
2004 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
2008 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
2010 std::stringstream out;
2011 out << index << ", " << divisor;
2012 TraceCallStack::NamedParams namedParams;
2013 namedParams["index"] << index;
2014 namedParams["divisor"] << divisor;
2015 mBufferTrace.PushCall("VertexAttribDivisor", out.str(), namedParams);
2018 inline void BindTransformFeedback(GLenum target, GLuint id) override
2022 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
2026 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
2030 inline GLboolean IsTransformFeedback(GLuint id) override
2035 inline void PauseTransformFeedback(void) override
2039 inline void ResumeTransformFeedback(void) override
2043 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2045 mGetProgramBinaryCalled = true;
2048 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2052 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2056 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2060 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2064 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2068 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2072 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2076 inline void BlendBarrier(void)
2081 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2083 std::string name = "<not found>";
2084 bool matched = false;
2086 UniformIDMap& map = mUniforms[mCurrentProgram];
2087 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2089 if(it->second == location)
2099 mSetUniformTrace.PushCall(name, value);
2103 public: // TEST FUNCTIONS
2104 inline void SetCompileStatus(GLuint value)
2106 mCompileStatus = value;
2108 inline void SetLinkStatus(GLuint value)
2110 mLinkStatus = value;
2112 inline void SetAttribLocations(std::vector<std::string>& locs)
2116 inline void SetAttribTypes(std::vector<GLenum>& types)
2118 mAttribTypes = types;
2120 inline void SetGetErrorResult(GLenum result)
2122 mGetErrorResult = result;
2124 inline void SetGetStringResult(GLubyte* result)
2126 mGetStringResult = result;
2128 inline void SetIsBufferResult(GLboolean result)
2130 mIsBufferResult = result;
2132 inline void SetIsEnabledResult(GLboolean result)
2134 mIsEnabledResult = result;
2136 inline void SetIsFramebufferResult(GLboolean result)
2138 mIsFramebufferResult = result;
2140 inline void SetIsProgramResult(GLboolean result)
2142 mIsProgramResult = result;
2144 inline void SetIsRenderbufferResult(GLboolean result)
2146 mIsRenderbufferResult = result;
2148 inline void SetIsShaderResult(GLboolean result)
2150 mIsShaderResult = result;
2152 inline void SetIsTextureResult(GLboolean result)
2154 mIsTextureResult = result;
2156 inline void SetCheckFramebufferStatusResult(GLenum result)
2158 mCheckFramebufferStatusResult = result;
2160 inline void SetNumBinaryFormats(GLint numFormats)
2162 mNumBinaryFormats = numFormats;
2164 inline void SetBinaryFormats(GLint binaryFormats)
2166 mBinaryFormats = binaryFormats;
2168 inline void SetProgramBinaryLength(GLint length)
2170 mProgramBinaryLength = length;
2173 inline bool GetVertexAttribArrayState(GLuint index)
2175 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2180 return mVertexAttribArrayState[index];
2182 inline void ClearVertexAttribArrayChanged()
2184 mVertexAttribArrayChanged = false;
2186 inline bool GetVertexAttribArrayChanged()
2188 return mVertexAttribArrayChanged;
2191 //Methods for CullFace verification
2192 inline void EnableCullFaceCallTrace(bool enable)
2194 mCullFaceTrace.Enable(enable);
2196 inline void ResetCullFaceCallStack()
2198 mCullFaceTrace.Reset();
2200 inline TraceCallStack& GetCullFaceTrace()
2202 return mCullFaceTrace;
2205 //Methods for Enable/Disable call verification
2206 inline void EnableEnableDisableCallTrace(bool enable)
2208 mEnableDisableTrace.Enable(enable);
2210 inline void ResetEnableDisableCallStack()
2212 mEnableDisableTrace.Reset();
2214 inline TraceCallStack& GetEnableDisableTrace()
2216 return mEnableDisableTrace;
2219 //Methods for Shader verification
2220 inline void EnableShaderCallTrace(bool enable)
2222 mShaderTrace.Enable(enable);
2224 inline void ResetShaderCallStack()
2226 mShaderTrace.Reset();
2228 inline TraceCallStack& GetShaderTrace()
2230 return mShaderTrace;
2233 //Methods for Texture verification
2234 inline void EnableTextureCallTrace(bool enable)
2236 mTextureTrace.Enable(enable);
2238 inline void ResetTextureCallStack()
2240 mTextureTrace.Reset();
2242 inline TraceCallStack& GetTextureTrace()
2244 return mTextureTrace;
2247 //Methods for Texture verification
2248 inline void EnableTexParameterCallTrace(bool enable)
2250 mTexParameterTrace.Enable(enable);
2252 inline void ResetTexParameterCallStack()
2254 mTexParameterTrace.Reset();
2256 inline TraceCallStack& GetTexParameterTrace()
2258 return mTexParameterTrace;
2261 //Methods for Draw verification
2262 inline void EnableDrawCallTrace(bool enable)
2264 mDrawTrace.Enable(enable);
2266 inline void ResetDrawCallStack()
2270 inline TraceCallStack& GetDrawTrace()
2275 //Methods for Depth function verification
2276 inline void EnableDepthFunctionCallTrace(bool enable)
2278 mDepthFunctionTrace.Enable(enable);
2280 inline void ResetDepthFunctionCallStack()
2282 mDepthFunctionTrace.Reset();
2284 inline TraceCallStack& GetDepthFunctionTrace()
2286 return mDepthFunctionTrace;
2289 //Methods for Stencil function verification
2290 inline void EnableStencilFunctionCallTrace(bool enable)
2292 mStencilFunctionTrace.Enable(enable);
2294 inline void ResetStencilFunctionCallStack()
2296 mStencilFunctionTrace.Reset();
2298 inline TraceCallStack& GetStencilFunctionTrace()
2300 return mStencilFunctionTrace;
2303 //Methods for Scissor verification
2304 inline void EnableScissorCallTrace(bool enable)
2306 mScissorTrace.Enable(enable);
2308 inline void ResetScissorCallStack()
2310 mScissorTrace.Reset();
2312 inline TraceCallStack& GetScissorTrace()
2314 return mScissorTrace;
2317 //Methods for Uniform function verification
2318 inline void EnableSetUniformCallTrace(bool enable)
2320 mSetUniformTrace.Enable(enable);
2322 inline void ResetSetUniformCallStack()
2324 mSetUniformTrace.Reset();
2326 inline TraceCallStack& GetSetUniformTrace()
2328 return mSetUniformTrace;
2331 //Methods for Viewport verification
2332 inline void EnableViewportCallTrace(bool enable)
2334 mViewportTrace.Enable(enable);
2336 inline void ResetViewportCallStack()
2338 mViewportTrace.Reset();
2340 inline TraceCallStack& GetViewportTrace()
2342 return mViewportTrace;
2344 inline TraceCallStack& GetBufferTrace()
2346 return mBufferTrace;
2349 template<typename T>
2350 inline bool GetUniformValue(const char* name, T& value) const
2352 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2353 program_it != mUniforms.end();
2356 const UniformIDMap& uniformIDs = program_it->second;
2358 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2359 if(uniform_it != uniformIDs.end())
2361 // found one matching uniform name, lets check the value...
2362 GLuint programId = program_it->first;
2363 GLint uniformId = uniform_it->second;
2365 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2366 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2372 template<typename T>
2373 inline bool CheckUniformValue(const char* name, const T& value) const
2375 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2376 program_it != mUniforms.end();
2379 const UniformIDMap& uniformIDs = program_it->second;
2381 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2382 if(uniform_it != uniformIDs.end())
2384 // found one matching uniform name, lets check the value...
2385 GLuint programId = program_it->first;
2386 GLint uniformId = uniform_it->second;
2388 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2389 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2391 // the value matches
2397 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2398 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2399 program_it != mUniforms.end();
2402 const UniformIDMap& uniformIDs = program_it->second;
2404 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2405 if(uniform_it != uniformIDs.end())
2407 // found one matching uniform name, lets check the value...
2408 GLuint programId = program_it->first;
2409 GLint uniformId = uniform_it->second;
2411 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2413 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2415 std::stringstream out;
2416 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2417 fprintf(stderr, "%s\n", out.str().c_str());
2424 template<typename T>
2425 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2427 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2428 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2431 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2433 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2434 program_it != mUniforms.end();
2437 const UniformIDMap& uniformIDs = program_it->second;
2439 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2440 if(uniform_it != uniformIDs.end())
2442 programId = program_it->first;
2443 uniformId = uniform_it->second;
2450 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2452 mCustomUniformData = customUniformData;
2455 inline GLuint GetLastShaderCompiled() const
2457 return mLastShaderCompiled;
2460 inline GLuint GetLastProgramCreated() const
2462 return mLastProgramIdUsed;
2465 inline GLbitfield GetLastClearMask() const
2467 return mLastClearBitMask;
2472 ATTRIB_UNKNOWN = -1,
2477 ATTRIB_BONE_WEIGHTS,
2478 ATTRIB_BONE_INDICES,
2482 struct ScissorParams
2498 // Methods to check scissor tests
2499 inline const ScissorParams& GetScissorParams() const
2501 return mScissorParams;
2504 struct ColorMaskParams
2520 inline bool GetProgramBinaryCalled() const
2522 return mGetProgramBinaryCalled;
2525 inline unsigned int GetClearCountCalled() const
2530 inline const ColorMaskParams& GetColorMaskParams() const
2532 return mColorMaskParams;
2535 typedef std::vector<size_t> BufferDataCalls;
2536 inline const BufferDataCalls& GetBufferDataCalls() const
2538 return mBufferDataCalls;
2540 inline void ResetBufferDataCalls()
2542 mBufferDataCalls.clear();
2545 typedef std::vector<size_t> BufferSubDataCalls;
2546 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2548 return mBufferSubDataCalls;
2550 inline void ResetBufferSubDataCalls()
2552 mBufferSubDataCalls.clear();
2556 GLuint mCurrentProgram;
2557 GLuint mCompileStatus;
2558 BufferDataCalls mBufferDataCalls;
2559 BufferSubDataCalls mBufferSubDataCalls;
2560 GLvoid* mMappedBuffer{nullptr};
2562 GLenum mGetErrorResult;
2563 GLubyte* mGetStringResult;
2564 GLboolean mIsBufferResult;
2565 GLboolean mIsEnabledResult;
2566 GLboolean mIsFramebufferResult;
2567 GLboolean mIsProgramResult;
2568 GLboolean mIsRenderbufferResult;
2569 GLboolean mIsShaderResult;
2570 GLboolean mIsTextureResult;
2571 GLenum mActiveTextureUnit;
2572 GLenum mCheckFramebufferStatusResult;
2573 GLint mFramebufferStatus;
2574 GLenum mFramebufferDepthAttached;
2575 GLenum mFramebufferStencilAttached;
2576 GLenum mFramebufferDepthStencilAttached;
2577 GLuint mFramebufferColorAttachmentCount;
2578 GLuint mFrameBufferColorStatus;
2579 GLuint mFramebufferDepthAttachmentCount;
2580 GLuint mFramebufferStencilAttachmentCount;
2581 GLuint mFramebufferDepthStencilAttachmentCount;
2582 GLint mNumBinaryFormats;
2583 GLint mBinaryFormats;
2584 GLint mProgramBinaryLength;
2585 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2586 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2587 bool mGetProgramBinaryCalled;
2588 typedef std::map<GLuint, std::string> ShaderSourceMap;
2589 ShaderSourceMap mShaderSources;
2590 std::vector<std::string> mAttribLocs; // should be bound to shader
2591 std::vector<GLenum> mAttribTypes; // should be bound to shader
2592 GLuint mLastShaderCompiled;
2593 GLbitfield mLastClearBitMask;
2594 Vector4 mLastClearColor;
2595 unsigned int mClearCount;
2597 Vector4 mLastBlendColor;
2598 GLenum mLastBlendEquationRgb;
2599 GLenum mLastBlendEquationAlpha;
2600 GLenum mLastBlendFuncSrcRgb;
2601 GLenum mLastBlendFuncDstRgb;
2602 GLenum mLastBlendFuncSrcAlpha;
2603 GLenum mLastBlendFuncDstAlpha;
2605 GLboolean mLastDepthMask;
2607 // Data for manipulating the IDs returned by GenTextures
2608 GLuint mLastAutoTextureIdUsed;
2609 GLuint mNumGeneratedTextures;
2610 std::vector<GLuint> mNextTextureIds;
2611 std::vector<GLuint> mDeletedTextureIds;
2612 std::vector<GLuint> mBoundTextures;
2614 struct ActiveTextureType
2616 std::vector<GLuint> mBoundTextures;
2619 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2621 TraceCallStack mBufferTrace;
2622 TraceCallStack mCullFaceTrace;
2623 TraceCallStack mEnableDisableTrace;
2624 TraceCallStack mShaderTrace;
2625 TraceCallStack mTextureTrace;
2626 TraceCallStack mTexParameterTrace;
2627 TraceCallStack mDrawTrace;
2628 TraceCallStack mDepthFunctionTrace;
2629 TraceCallStack mStencilFunctionTrace;
2630 TraceCallStack mScissorTrace;
2631 TraceCallStack mSetUniformTrace;
2632 TraceCallStack mViewportTrace;
2634 // Shaders & Uniforms
2635 GLuint mLastShaderIdUsed;
2636 GLuint mLastProgramIdUsed{0u};
2637 GLuint mLastUniformIdUsed;
2638 typedef std::map<std::string, GLint> UniformIDMap;
2639 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2640 ProgramUniformMap mUniforms;
2641 std::vector<ActiveUniform> mActiveUniforms;
2642 std::vector<UniformData> mCustomUniformData{};
2644 template<typename T>
2645 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2648 typedef std::map<GLint, T> UniformValueMap;
2649 typedef std::map<GLuint, UniformValueMap> Map;
2651 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2658 typename Map::iterator it = Map::find(program);
2659 if(it == Map::end())
2661 // if its the first uniform for this program add it
2662 std::pair<typename Map::iterator, bool> result =
2663 Map::insert(typename Map::value_type(program, UniformValueMap()));
2667 UniformValueMap& uniforms = it->second;
2668 uniforms[uniform] = value;
2673 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2676 if(GetUniformValue(program, uniform, uniformValue))
2678 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2684 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2691 typename Map::const_iterator it = Map::find(program);
2692 if(it == Map::end())
2694 // Uniform values always initialised as 0
2699 const UniformValueMap& uniforms = it->second;
2700 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2701 if(it2 == uniforms.end())
2703 // Uniform values always initialised as 0
2707 value = it2->second;
2714 ProgramUniformValue<int> mProgramUniforms1i;
2715 ProgramUniformValue<float> mProgramUniforms1f;
2716 ProgramUniformValue<Vector2> mProgramUniforms2f;
2717 ProgramUniformValue<Vector3> mProgramUniforms3f;
2718 ProgramUniformValue<Vector4> mProgramUniforms4f;
2719 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2720 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2722 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2724 return mProgramUniforms1i;
2726 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2728 return mProgramUniforms1f;
2730 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2732 return mProgramUniforms2f;
2734 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2736 return mProgramUniforms3f;
2738 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2740 return mProgramUniforms4f;
2742 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2744 return mProgramUniformsMat4;
2746 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2748 return mProgramUniformsMat3;
2750 inline void SetVertexAttribArray(GLuint index, bool state)
2752 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2757 mVertexAttribArrayState[index] = state;
2758 mVertexAttribArrayChanged = true;
2761 ScissorParams mScissorParams;
2762 ColorMaskParams mColorMaskParams;
2766 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2772 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2778 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2780 return Vector2::ZERO;
2784 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2786 return Vector3::ZERO;
2790 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2792 return Vector4::ZERO;
2796 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2802 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2804 return Matrix3(Matrix());
2809 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2810 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2812 #endif // TEST_GL_ABSTRACTION_H