1 #ifndef TEST_GL_ABSTRACTION_H
2 #define TEST_GL_ABSTRACTION_H
5 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
24 #include <cstring> // for strcmp
31 #include <dali/devel-api/rendering/frame-buffer-devel.h>
32 #include <dali/integration-api/core.h>
33 #include <dali/integration-api/gl-abstraction.h>
34 #include <dali/integration-api/gl-defines.h>
35 #include <dali/public-api/dali-core.h>
36 #include <test-compare-types.h>
37 #include <test-trace-call-stack.h>
45 UniformData(const std::string& name, Property::Type type = Property::Type::NONE)
59 class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
62 static const int MAX_ATTRIBUTE_CACHE_SIZE{64};
65 ~TestGlAbstraction() override;
68 void PreRender() override;
69 void PostRender() override;
71 bool IsSurfacelessContextSupported() const override;
73 bool IsAdvancedBlendEquationSupported() override;
75 bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) override;
77 std::string GetShaderVersionPrefix();
79 std::string GetVertexShaderPrefix();
81 std::string GetFragmentShaderPrefix();
83 bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
87 inline void ActiveTexture(GLenum textureUnit) override
89 mActiveTextureUnit = textureUnit - GL_TEXTURE0;
92 inline GLenum GetActiveTextureUnit() const
94 return mActiveTextureUnit + GL_TEXTURE0;
97 inline void AttachShader(GLuint program, GLuint shader) override
99 std::stringstream out;
100 out << program << ", " << shader;
102 TraceCallStack::NamedParams namedParams;
103 namedParams["program"] << program;
104 namedParams["shader"] << shader;
105 mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
108 inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
112 inline void BindBuffer(GLenum target, GLuint buffer) override
114 std::ostringstream o;
115 o << std::hex << target << ", " << buffer;
116 TraceCallStack::NamedParams namedParams;
117 namedParams["target"] << target;
118 namedParams["buffer"] << buffer;
119 mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
122 inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
125 mFramebufferStatus |= 2;
128 inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
133 * This method can be used by test cases, to query the texture IDs that have been bound by BindTexture.
134 * @return A vector containing the IDs that were bound.
136 inline const std::vector<GLuint>& GetBoundTextures() const
138 return mBoundTextures;
142 * Query the texture IDs that have been bound with BindTexture, with a specific active texture unit.
143 * @param[in] activeTextureUnit The specific active texture unit.
144 * @return A vector containing the IDs that were bound.
146 inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
148 return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
152 * This method can be used by test cases, to clear the record of texture IDs that have been bound by BindTexture.
154 inline void ClearBoundTextures()
156 mBoundTextures.clear();
158 for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
160 mActiveTextures[i].mBoundTextures.clear();
164 inline void BindTexture(GLenum target, GLuint texture) override
166 // Record the bound textures for future checks
169 mBoundTextures.push_back(texture);
171 if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
173 mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
177 std::stringstream out;
178 out << std::hex << target << ", " << std::dec << texture;
180 TraceCallStack::NamedParams namedParams;
181 namedParams["target"] << std::hex << target;
182 namedParams["texture"] << texture;
184 mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
187 inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
189 mLastBlendColor.r = red;
190 mLastBlendColor.g = green;
191 mLastBlendColor.b = blue;
192 mLastBlendColor.a = alpha;
195 inline const Vector4& GetLastBlendColor() const
197 return mLastBlendColor;
200 inline void BlendEquation(GLenum mode) override
202 mLastBlendEquationRgb = mode;
203 mLastBlendEquationAlpha = mode;
206 inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
208 mLastBlendEquationRgb = modeRgb;
209 mLastBlendEquationAlpha = modeAlpha;
212 inline GLenum GetLastBlendEquationRgb() const
214 return mLastBlendEquationRgb;
217 inline GLenum GetLastBlendEquationAlpha() const
219 return mLastBlendEquationAlpha;
222 inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
224 mLastBlendFuncSrcRgb = sfactor;
225 mLastBlendFuncDstRgb = dfactor;
226 mLastBlendFuncSrcAlpha = sfactor;
227 mLastBlendFuncDstAlpha = dfactor;
230 inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
232 mLastBlendFuncSrcRgb = srcRGB;
233 mLastBlendFuncDstRgb = dstRGB;
234 mLastBlendFuncSrcAlpha = srcAlpha;
235 mLastBlendFuncDstAlpha = dstAlpha;
238 inline GLenum GetLastBlendFuncSrcRgb() const
240 return mLastBlendFuncSrcRgb;
243 inline GLenum GetLastBlendFuncDstRgb() const
245 return mLastBlendFuncDstRgb;
248 inline GLenum GetLastBlendFuncSrcAlpha() const
250 return mLastBlendFuncSrcAlpha;
253 inline GLenum GetLastBlendFuncDstAlpha() const
255 return mLastBlendFuncDstAlpha;
258 inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
260 std::ostringstream o;
261 o << std::hex << target << ", " << size << ", " << data << ", " << usage;
262 TraceCallStack::NamedParams namedParams;
263 namedParams["target"] << std::hex << target;
264 namedParams["size"] << size;
265 namedParams["usage"] << usage;
267 mBufferTrace.PushCall("BufferData", o.str(), namedParams);
269 mBufferDataCalls.push_back(size);
272 inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
274 std::ostringstream o;
275 o << std::hex << target << ", " << offset << ", " << size << ", " << data;
276 TraceCallStack::NamedParams namedParams;
277 namedParams["target"] << std::hex << target;
278 namedParams["offset"] << offset;
279 namedParams["size"] << size;
280 mBufferTrace.PushCall("BufferSubData", o.str());
282 mBufferSubDataCalls.push_back(size);
285 inline GLenum CheckFramebufferStatus(GLenum target) override
287 //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
288 //Framebuffer texture have been called
289 if(mFramebufferStatus == 7)
291 return GL_FRAMEBUFFER_COMPLETE;
294 return mCheckFramebufferStatusResult;
297 inline GLuint CheckFramebufferColorAttachmentCount()
299 return mFramebufferColorAttachmentCount;
302 inline GLuint CheckFramebufferDepthAttachmentCount()
304 return mFramebufferDepthAttachmentCount;
307 inline GLuint CheckFramebufferStencilAttachmentCount()
309 return mFramebufferStencilAttachmentCount;
312 inline GLuint CheckFramebufferDepthStencilAttachmentCount()
314 return mFramebufferDepthStencilAttachmentCount;
317 inline GLenum CheckFramebufferDepthAttachment()
319 return mFramebufferDepthAttached;
322 inline GLenum CheckFramebufferStencilAttachment()
324 return mFramebufferStencilAttached;
327 inline GLenum CheckFramebufferDepthStencilAttachment()
329 return mFramebufferDepthStencilAttached;
332 inline void Clear(GLbitfield mask) override
335 mLastClearBitMask = mask;
338 inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
340 mLastClearColor.r = red;
341 mLastClearColor.g = green;
342 mLastClearColor.b = blue;
343 mLastClearColor.a = alpha;
346 inline const Vector4& GetLastClearColor() const
348 return mLastClearColor;
351 inline void ClearDepthf(GLclampf depth) override
355 inline void ClearStencil(GLint s) override
357 std::stringstream out;
360 TraceCallStack::NamedParams namedParams;
361 namedParams["s"] << s;
363 mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
366 inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
368 mColorMaskParams.red = red;
369 mColorMaskParams.green = green;
370 mColorMaskParams.blue = blue;
371 mColorMaskParams.alpha = alpha;
374 inline void CompileShader(GLuint shader) override
376 std::stringstream out;
378 TraceCallStack::NamedParams namedParams;
379 namedParams["shader"] << shader;
381 mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
384 inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
386 std::stringstream out;
387 out << target << ", " << level << ", " << width << ", " << height;
389 TraceCallStack::NamedParams namedParams;
390 namedParams["target"] << std::hex << target;
391 namedParams["level"] << level;
392 namedParams["internalformat"] << internalformat;
393 namedParams["width"] << width;
394 namedParams["height"] << height;
395 namedParams["border"] << border;
396 namedParams["size"] << imageSize;
398 mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
401 inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
403 std::stringstream out;
404 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
406 TraceCallStack::NamedParams namedParams;
407 namedParams["target"] << std::hex << target;
408 namedParams["level"] << level;
409 namedParams["xoffset"] << xoffset;
410 namedParams["yoffset"] << yoffset;
411 namedParams["width"] << width;
412 namedParams["height"] << height;
413 mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
416 inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
420 inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
424 inline GLuint CreateProgram(void) override
426 mShaderTrace.PushCall("CreateProgram", "");
428 ++mLastProgramIdUsed;
429 mUniforms[mLastProgramIdUsed] = UniformIDMap();
430 return mLastProgramIdUsed;
433 inline GLuint CreateShader(GLenum type) override
435 std::stringstream out;
438 TraceCallStack::NamedParams namedParams;
439 namedParams["type"] << std::hex << type;
440 mShaderTrace.PushCall("CreateShader", out.str(), namedParams);
442 return ++mLastShaderIdUsed;
445 inline void CullFace(GLenum mode) override
447 std::stringstream out;
448 out << std::hex << mode;
450 TraceCallStack::NamedParams namedParams;
451 namedParams["mode"] << std::hex << mode;
453 mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
456 inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
460 inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
464 inline void DeleteProgram(GLuint program) override
466 std::stringstream out;
469 TraceCallStack::NamedParams namedParams;
470 namedParams["program"] << program;
472 mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
475 inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
479 inline void DeleteShader(GLuint shader) override
481 std::stringstream out;
484 TraceCallStack::NamedParams namedParams;
485 namedParams["shader"] << shader;
487 mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
490 inline void DeleteTextures(GLsizei n, const GLuint* textures) override
492 std::stringstream out;
493 out << "n:" << n << " textures[";
495 TraceCallStack::NamedParams namedParams;
497 for(GLsizei i = 0; i < n; i++)
499 out << (i > 0 ? ", " : "") << textures[i];
500 std::stringstream paramName;
501 paramName << "texture[" << i << "]";
502 namedParams[paramName.str()] << textures[i];
503 mDeletedTextureIds.push_back(textures[i]);
504 mNumGeneratedTextures--;
508 mTextureTrace.PushCall("DeleteTextures", out.str(), namedParams);
511 inline bool CheckNoTexturesDeleted()
513 return mDeletedTextureIds.size() == 0;
516 inline bool CheckTextureDeleted(GLuint textureId)
520 for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
522 if(*iter == textureId)
531 inline void ClearDeletedTextures()
533 mDeletedTextureIds.clear();
536 inline void DepthFunc(GLenum func) override
538 std::stringstream out;
539 out << std::hex << func;
541 TraceCallStack::NamedParams namedParams;
542 namedParams["func"] << std::hex << func;
544 mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
547 inline void DepthMask(GLboolean flag) override
549 mLastDepthMask = flag;
552 inline bool GetLastDepthMask() const
554 return mLastDepthMask;
557 inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
561 inline void DetachShader(GLuint program, GLuint shader) override
563 std::stringstream out;
564 out << program << ", " << shader;
565 TraceCallStack::NamedParams namedParams;
566 namedParams["program"] << program;
567 namedParams["shader"] << shader;
568 mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
571 inline void Disable(GLenum cap) override
573 std::stringstream out;
574 out << std::hex << cap;
575 TraceCallStack::NamedParams namedParams;
576 namedParams["cap"] << std::hex << cap;
577 mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
580 inline void DisableVertexAttribArray(GLuint index) override
582 std::stringstream out;
584 TraceCallStack::NamedParams namedParams;
585 namedParams["index"] << index;
586 mBufferTrace.PushCall("DisableVertexAttribArray", out.str(), namedParams);
587 SetVertexAttribArray(index, false);
590 inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
592 std::stringstream out;
593 out << mode << ", " << first << ", " << count;
594 TraceCallStack::NamedParams namedParams;
595 namedParams["mode"] << std::hex << mode;
596 namedParams["first"] << first;
597 namedParams["count"] << count;
598 mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
601 inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
603 std::stringstream out;
604 out << mode << ", " << count << ", " << type << ", indices";
606 TraceCallStack::NamedParams namedParams;
607 namedParams["mode"] << std::hex << mode;
608 namedParams["count"] << count;
609 namedParams["type"] << type;
610 // Skip void pointers - are they of any use?
611 mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
614 inline void Enable(GLenum cap) override
616 std::stringstream out;
617 out << std::hex << cap;
618 TraceCallStack::NamedParams namedParams;
619 namedParams["cap"] << std::hex << cap;
620 mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
623 inline void EnableVertexAttribArray(GLuint index) override
625 std::stringstream out;
627 TraceCallStack::NamedParams namedParams;
628 namedParams["index"] << index;
629 mBufferTrace.PushCall("EnableVertexAttribArray", out.str(), namedParams);
630 SetVertexAttribArray(index, true);
633 inline void Finish(void) override
637 inline void Flush(void) override
641 inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
643 if(attachment == GL_DEPTH_ATTACHMENT)
645 mFramebufferDepthAttached = true;
647 else if(attachment == GL_STENCIL_ATTACHMENT)
649 mFramebufferStencilAttached = true;
651 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
653 mFramebufferStencilAttached = true;
654 mFramebufferDepthAttached = true;
655 mFramebufferDepthStencilAttached = true;
659 inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
662 mFramebufferStatus |= 4;
664 //We check 4 attachment colors
665 if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
667 uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
668 if((mFrameBufferColorStatus & mask) == 0)
670 mFrameBufferColorStatus |= mask;
671 ++mFramebufferColorAttachmentCount;
674 else if(attachment == GL_DEPTH_ATTACHMENT)
676 ++mFramebufferDepthAttachmentCount;
678 else if(attachment == GL_STENCIL_ATTACHMENT)
680 ++mFramebufferStencilAttachmentCount;
682 else if(attachment == GL_DEPTH_STENCIL_ATTACHMENT)
684 ++mFramebufferDepthAttachmentCount;
685 ++mFramebufferStencilAttachmentCount;
686 ++mFramebufferDepthStencilAttachmentCount;
690 inline void FrontFace(GLenum mode) override
695 inline void GenBuffers(GLsizei n, GLuint* buffers) override
697 // avoids an assert in GpuBuffers
700 std::ostringstream o;
702 TraceCallStack::NamedParams namedParams;
703 namedParams["n"] << o.str();
704 mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
707 inline void GenerateMipmap(GLenum target) override
709 std::stringstream out;
711 TraceCallStack::NamedParams namedParams;
712 namedParams["target"] << std::hex << target;
714 mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
717 inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
719 for(int i = 0; i < n; i++)
721 framebuffers[i] = i + 1;
724 //Add 001 bit, this function needs to be called the first one in the chain
725 mFramebufferStatus = 1;
728 inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
730 for(int i = 0; i < n; i++)
732 renderbuffers[i] = i + 1;
737 * This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
738 * @param[in] ids A vector containing the next IDs to be generated
740 inline void SetNextTextureIds(const std::vector<GLuint>& ids)
742 mNextTextureIds = ids;
745 inline const std::vector<GLuint>& GetNextTextureIds()
747 return mNextTextureIds;
750 inline void GenTextures(GLsizei count, GLuint* textures) override
752 for(int i = 0; i < count; ++i)
754 if(!mNextTextureIds.empty())
756 *(textures + i) = mNextTextureIds[0];
757 mNextTextureIds.erase(mNextTextureIds.begin());
761 *(textures + i) = ++mLastAutoTextureIdUsed;
763 mNumGeneratedTextures++;
766 TraceCallStack::NamedParams namedParams;
767 namedParams["count"] << count;
769 std::stringstream out;
770 for(int i = 0; i < count; i++)
777 std::ostringstream oss;
778 oss << "indices[" << i << "]";
779 namedParams[oss.str()] << textures[i];
782 mTextureTrace.PushCall("GenTextures", out.str(), namedParams);
785 inline GLuint GetLastGenTextureId()
787 return mLastAutoTextureIdUsed;
790 inline GLuint GetNumGeneratedTextures()
792 return mNumGeneratedTextures;
795 inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
799 inline void SetActiveUniforms(const std::vector<ActiveUniform>& uniforms)
801 mActiveUniforms = uniforms;
804 inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
806 if(index < mActiveUniforms.size())
808 *length = snprintf(name, bufsize, "%s", mActiveUniforms[index].name.c_str());
809 *type = mActiveUniforms[index].type;
810 *size = mActiveUniforms[index].size;
814 inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
818 inline int GetAttribLocation(GLuint program, const char* name) override
820 std::string check(name);
821 auto iter = std::find(mAttribLocs.begin(), mAttribLocs.end(), check);
822 if(iter == mAttribLocs.end())
824 return iter - mAttribLocs.begin();
827 inline void GetBooleanv(GLenum pname, GLboolean* params) override
831 inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
835 inline GLenum GetError(void) override
837 return mGetErrorResult;
840 inline void GetFloatv(GLenum pname, GLfloat* params) override
844 inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
848 inline void GetIntegerv(GLenum pname, GLint* params) override
852 case GL_MAX_TEXTURE_SIZE:
855 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
858 case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
859 *params = mNumBinaryFormats;
861 case GL_PROGRAM_BINARY_FORMATS_OES:
862 *params = mBinaryFormats;
867 inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
872 *params = mLinkStatus;
874 case GL_PROGRAM_BINARY_LENGTH_OES:
875 *params = mProgramBinaryLength;
877 case GL_ACTIVE_UNIFORMS:
878 *params = mActiveUniforms.size();
880 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
883 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
889 inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
893 inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
897 inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
901 case GL_COMPILE_STATUS:
902 *params = mCompileStatus;
907 inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
911 inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
915 inline const GLubyte* GetString(GLenum name) override
917 return mGetStringResult;
920 inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
924 inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
928 inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
932 inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
936 inline GLint GetUniformLocation(GLuint program, const char* name) override
938 ProgramUniformMap::iterator it = mUniforms.find(program);
939 if(it == mUniforms.end())
941 // Not a valid program ID
942 mGetErrorResult = GL_INVALID_OPERATION;
946 UniformIDMap& uniformIDs = it->second;
947 UniformIDMap::iterator it2 = uniformIDs.find(name);
948 if(it2 == uniformIDs.end())
950 // Uniform not found, so add it...
951 uniformIDs[name] = ++mLastUniformIdUsed;
952 return uniformIDs[name];
958 inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
962 inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
966 inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
970 inline void Hint(GLenum target, GLenum mode) override
974 inline GLboolean IsBuffer(GLuint buffer) override
976 return mIsBufferResult;
979 inline GLboolean IsEnabled(GLenum cap) override
981 return mIsEnabledResult;
984 inline GLboolean IsFramebuffer(GLuint framebuffer) override
986 return mIsFramebufferResult;
989 inline GLboolean IsProgram(GLuint program) override
991 return mIsProgramResult;
994 inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
996 return mIsRenderbufferResult;
999 inline GLboolean IsShader(GLuint shader) override
1001 return mIsShaderResult;
1004 inline GLboolean IsTexture(GLuint texture) override
1006 return mIsTextureResult;
1009 inline void LineWidth(GLfloat width) override
1013 inline void LinkProgram(GLuint program) override
1015 std::stringstream out;
1018 TraceCallStack::NamedParams namedParams;
1019 namedParams["program"] << program;
1020 mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
1022 for(const auto& uniform : mActiveUniforms)
1024 GetUniformLocation(program, uniform.name.c_str());
1027 for(const auto& uniform : mCustomUniformData)
1029 auto iter = uniform.name.find("[");
1030 auto name = uniform.name;
1031 if(iter != std::string::npos)
1033 name = uniform.name.substr(0, iter);
1034 auto arrayCount = std::stoi(uniform.name.substr(iter + 1));
1035 iter = uniform.name.find("]");
1037 if(iter != std::string::npos && iter + 1 != uniform.name.length())
1039 suffix = uniform.name.substr(iter + 1); // If there is a suffix, it means its an element of an array of struct
1042 for(int i = 0; i < arrayCount; ++i)
1044 std::stringstream nss;
1045 nss << name << "[" << i << "]" << suffix;
1046 GetUniformLocation(program, nss.str().c_str()); // Generate a GL loc per element
1051 GetUniformLocation(program, name.c_str());
1056 inline void PixelStorei(GLenum pname, GLint param) override
1060 inline void PolygonOffset(GLfloat factor, GLfloat units) override
1064 inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
1068 inline void ReleaseShaderCompiler(void) override
1072 inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
1076 inline void SampleCoverage(GLclampf value, GLboolean invert) override
1080 inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
1082 mScissorParams.x = x;
1083 mScissorParams.y = y;
1084 mScissorParams.width = width;
1085 mScissorParams.height = height;
1087 std::stringstream out;
1088 out << x << ", " << y << ", " << width << ", " << height;
1089 TraceCallStack::NamedParams namedParams;
1090 namedParams["x"] << x;
1091 namedParams["y"] << y;
1092 namedParams["width"] << width;
1093 namedParams["height"] << height;
1094 mScissorTrace.PushCall("Scissor", out.str(), namedParams);
1097 inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
1101 inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
1103 std::string stringBuilder;
1104 for(int i = 0; i < count; ++i)
1106 stringBuilder += string[i];
1108 mShaderSources[shader] = stringBuilder;
1109 mLastShaderCompiled = shader;
1112 inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
1114 const std::string shaderSource = mShaderSources[shader];
1115 const int shaderSourceLength = static_cast<int>(shaderSource.length());
1116 if(shaderSourceLength < bufsize)
1118 strncpy(source, shaderSource.c_str(), shaderSourceLength);
1119 *length = shaderSourceLength;
1123 *length = bufsize - 1;
1124 strncpy(source, shaderSource.c_str(), *length);
1125 source[*length] = 0x0;
1129 inline std::string GetShaderSource(GLuint shader)
1131 return mShaderSources[shader];
1134 inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
1136 std::stringstream out;
1137 out << func << ", " << ref << ", " << mask;
1139 TraceCallStack::NamedParams namedParams;
1140 namedParams["func"] << std::hex << func;
1141 namedParams["ref"] << ref;
1142 namedParams["mask"] << mask;
1144 mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
1147 inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
1149 std::stringstream out;
1150 out << face << ", " << func << ", " << ref << ", " << mask;
1152 TraceCallStack::NamedParams namedParams;
1153 namedParams["face"] << std::hex << face;
1154 namedParams["func"] << std::hex << func;
1155 namedParams["ref"] << ref;
1156 namedParams["mask"] << mask;
1158 mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
1161 inline void StencilMask(GLuint mask) override
1163 std::stringstream out;
1166 TraceCallStack::NamedParams namedParams;
1167 namedParams["mask"] << mask;
1169 mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
1172 inline void StencilMaskSeparate(GLenum face, GLuint mask) override
1174 std::stringstream out;
1175 out << face << ", " << mask;
1177 TraceCallStack::NamedParams namedParams;
1178 namedParams["face"] << std::hex << face;
1179 namedParams["mask"] << mask;
1181 mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
1184 inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
1186 std::stringstream out;
1187 out << fail << ", " << zfail << ", " << zpass;
1189 TraceCallStack::NamedParams namedParams;
1190 namedParams["fail"] << std::hex << fail;
1191 namedParams["zfail"] << std::hex << zfail;
1192 namedParams["zpass"] << std::hex << zpass;
1194 mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
1197 inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
1199 std::stringstream out;
1200 out << face << ", " << fail << ", " << zfail << "," << zpass;
1202 TraceCallStack::NamedParams namedParams;
1203 namedParams["face"] << std::hex << face;
1204 namedParams["fail"] << std::hex << fail;
1205 namedParams["zfail"] << std::hex << zfail;
1206 namedParams["zpass"] << std::hex << zpass;
1208 mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
1211 inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
1213 std::stringstream out;
1214 out << target << ", " << level << ", " << width << ", " << height;
1216 TraceCallStack::NamedParams namedParams;
1217 namedParams["target"] << std::hex << target;
1218 namedParams["level"] << level;
1219 namedParams["internalformat"] << internalformat;
1220 namedParams["width"] << width;
1221 namedParams["height"] << height;
1222 namedParams["border"] << border;
1223 namedParams["format"] << std::hex << format;
1224 namedParams["type"] << std::hex << type;
1226 mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
1229 inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
1231 std::stringstream out;
1232 out << target << ", " << pname << ", " << param;
1234 TraceCallStack::NamedParams namedParams;
1235 namedParams["target"] << std::hex << target;
1236 namedParams["pname"] << std::hex << pname;
1237 namedParams["param"] << param;
1239 mTexParameterTrace.PushCall("TexParameterf", out.str(), namedParams);
1242 inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
1244 std::stringstream out;
1245 out << target << ", " << pname << ", " << params[0];
1247 TraceCallStack::NamedParams namedParams;
1248 namedParams["target"] << std::hex << target;
1249 namedParams["pname"] << std::hex << pname;
1250 namedParams["params[0]"] << params[0];
1252 mTexParameterTrace.PushCall("TexParameterfv", out.str(), namedParams);
1255 inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
1257 std::stringstream out;
1258 out << std::hex << target << ", " << pname << ", " << param;
1259 std::string params = out.str();
1261 TraceCallStack::NamedParams namedParams;
1262 namedParams["target"] << std::hex << target;
1263 namedParams["pname"] << std::hex << pname;
1264 namedParams["param"] << param;
1265 mTexParameterTrace.PushCall("TexParameteri", params, namedParams);
1268 inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1270 std::stringstream out;
1271 out << target << ", " << pname << ", " << params[0];
1272 TraceCallStack::NamedParams namedParams;
1273 namedParams["target"] << std::hex << target;
1274 namedParams["pname"] << std::hex << pname;
1275 namedParams["params[0]"] << params[0];
1276 mTexParameterTrace.PushCall("TexParameteriv", out.str(), namedParams);
1279 inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1281 std::stringstream out;
1282 out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
1284 TraceCallStack::NamedParams namedParams;
1285 namedParams["target"] << std::hex << target;
1286 namedParams["level"] << level;
1287 namedParams["xoffset"] << xoffset;
1288 namedParams["yoffset"] << yoffset;
1289 namedParams["width"] << width;
1290 namedParams["height"] << height;
1291 mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
1294 inline void Uniform1f(GLint location, GLfloat value) override
1296 std::string params = std::to_string(value);
1297 AddUniformCallToTraceStack(location, params);
1299 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
1301 mGetErrorResult = GL_INVALID_OPERATION;
1305 inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1308 for(int i = 0; i < count; ++i)
1310 params = params + std::to_string(v[i]) + ",";
1313 AddUniformCallToTraceStack(location, params);
1315 for(int i = 0; i < count; ++i)
1317 if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
1319 mGetErrorResult = GL_INVALID_OPERATION;
1325 inline void Uniform1i(GLint location, GLint x) override
1327 std::string params = std::to_string(x);
1329 AddUniformCallToTraceStack(location, params);
1331 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
1333 mGetErrorResult = GL_INVALID_OPERATION;
1337 inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1339 std::ostringstream out;
1340 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1341 AddUniformCallToTraceStack(location, out.str());
1343 for(int i = 0; i < count; ++i)
1345 if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
1349 mGetErrorResult = GL_INVALID_OPERATION;
1355 inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1357 std::string params = std::to_string(x) + "," + std::to_string(y);
1358 AddUniformCallToTraceStack(location, params);
1360 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1364 mGetErrorResult = GL_INVALID_OPERATION;
1368 inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1370 std::ostringstream out;
1371 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1372 AddUniformCallToTraceStack(location, out.str());
1374 for(int i = 0; i < count; ++i)
1376 if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
1378 Vector2(v[2 * i], v[2 * i + 1])))
1380 mGetErrorResult = GL_INVALID_OPERATION;
1386 inline void Uniform2i(GLint location, GLint x, GLint y) override
1388 std::string params = std::to_string(x) + "," + std::to_string(y);
1389 AddUniformCallToTraceStack(location, params);
1392 inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1394 std::ostringstream out;
1395 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1396 AddUniformCallToTraceStack(location, out.str());
1399 inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1401 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1402 AddUniformCallToTraceStack(location, params);
1404 if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
1408 mGetErrorResult = GL_INVALID_OPERATION;
1412 inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1414 std::ostringstream out;
1415 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1416 AddUniformCallToTraceStack(location, out.str());
1418 for(int i = 0; i < count; ++i)
1420 if(!mProgramUniforms3f.SetUniformValue(
1423 Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
1425 mGetErrorResult = GL_INVALID_OPERATION;
1431 inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1433 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z);
1434 AddUniformCallToTraceStack(location, params);
1437 inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1439 std::ostringstream out;
1440 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1441 AddUniformCallToTraceStack(location, out.str());
1444 inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1446 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1447 AddUniformCallToTraceStack(location, params);
1449 if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
1451 Vector4(x, y, z, w)))
1453 mGetErrorResult = GL_INVALID_OPERATION;
1457 inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1459 std::ostringstream out;
1460 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1461 AddUniformCallToTraceStack(location, out.str());
1463 for(int i = 0; i < count; ++i)
1465 if(!mProgramUniforms4f.SetUniformValue(
1468 Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
1470 mGetErrorResult = GL_INVALID_OPERATION;
1476 inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1478 std::string params = std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "," + std::to_string(w);
1479 AddUniformCallToTraceStack(location, params);
1482 inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1484 std::ostringstream out;
1485 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << v[i];
1486 AddUniformCallToTraceStack(location, out.str());
1489 inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1491 std::ostringstream out;
1492 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1493 AddUniformCallToTraceStack(location, out.str());
1496 inline void UniformMatrix3fv(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());
1502 for(int i = 0; i < count; ++i)
1504 if(!mProgramUniformsMat3.SetUniformValue(
1507 Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
1509 mGetErrorResult = GL_INVALID_OPERATION;
1515 inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1517 std::ostringstream out;
1518 for(GLsizei i = 0; i < count; ++i) out << (!i ? "" : ", ") << value[i];
1519 AddUniformCallToTraceStack(location, out.str());
1521 for(int i = 0; i < count; ++i)
1523 if(!mProgramUniformsMat4.SetUniformValue(
1528 mGetErrorResult = GL_INVALID_OPERATION;
1534 inline void UseProgram(GLuint program) override
1536 mCurrentProgram = program;
1539 inline void ValidateProgram(GLuint program) override
1543 inline void VertexAttrib1f(GLuint indx, GLfloat x) override
1547 inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1551 inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1555 inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1559 inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1563 inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1567 inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1571 inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1575 inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1577 TraceCallStack::NamedParams namedParams;
1578 namedParams["index"] << index;
1579 namedParams["size"] << size;
1580 namedParams["type"] << std::hex << type;
1581 namedParams["normalized"] << (normalized ? "T" : "F");
1582 namedParams["stride"] << stride;
1583 namedParams["offset"] << std::to_string(reinterpret_cast<unsigned long>(ptr));
1585 mBufferTrace.PushCall("VertexAttribPointer", namedParams.str(), namedParams);
1588 inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1590 std::string commaString(", ");
1591 std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
1593 mViewportTrace.PushCall("Viewport", params);
1598 inline void ReadBuffer(GLenum mode) override
1602 inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1606 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
1610 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
1614 inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1618 inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1622 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
1626 inline void GenQueries(GLsizei n, GLuint* ids) override
1630 inline void DeleteQueries(GLsizei n, const GLuint* ids) override
1634 inline GLboolean IsQuery(GLuint id) override
1639 inline void BeginQuery(GLenum target, GLuint id) override
1643 inline void EndQuery(GLenum target) override
1647 inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1651 inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1655 inline GLboolean UnmapBuffer(GLenum target) override
1659 free(mMappedBuffer);
1660 mMappedBuffer = nullptr;
1662 return true; // false indicates corruption, nothing else.
1665 inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1669 inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
1673 inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1677 inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1681 inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1685 inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1689 inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1693 inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1697 inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1701 inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1705 inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1709 inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1711 mMappedBuffer = reinterpret_cast<GLvoid*>(malloc(offset + length));
1712 return mMappedBuffer;
1715 inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1719 inline void BindVertexArray(GLuint array) override
1723 inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1727 inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
1731 inline GLboolean IsVertexArray(GLuint array) override
1736 inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1740 inline void BeginTransformFeedback(GLenum primitiveMode) override
1744 inline void EndTransformFeedback(void) override
1748 inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1752 inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1756 inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1760 inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1764 inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1768 inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1772 inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1776 inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1780 inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1784 inline void VertexAttribI4iv(GLuint index, const GLint* v) override
1788 inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1792 inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1796 inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1801 inline void Uniform1ui(GLint location, GLuint v0) override
1805 inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1809 inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1813 inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1817 inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1821 inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1825 inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1829 inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1833 inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1837 inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1841 inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1845 inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1849 inline const GLubyte* GetStringi(GLenum name, GLuint index) override
1854 inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1858 inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1862 inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1866 inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1868 return GL_INVALID_INDEX;
1871 inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1875 inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1879 inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1883 inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1887 inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1891 inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
1896 inline GLboolean IsSync(GLsync sync) override
1901 inline void DeleteSync(GLsync sync) override
1905 inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1910 inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1914 inline void GetInteger64v(GLenum pname, GLint64* params) override
1918 inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1922 inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1926 inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1930 inline void GenSamplers(GLsizei count, GLuint* samplers) override
1934 inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1938 inline GLboolean IsSampler(GLuint sampler) override
1943 inline void BindSampler(GLuint unit, GLuint sampler) override
1947 inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1951 inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1955 inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1959 inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1963 inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1967 inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1971 inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
1975 inline void BindTransformFeedback(GLenum target, GLuint id) override
1979 inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1983 inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1987 inline GLboolean IsTransformFeedback(GLuint id) override
1992 inline void PauseTransformFeedback(void) override
1996 inline void ResumeTransformFeedback(void) override
2000 inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
2002 mGetProgramBinaryCalled = true;
2005 inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
2009 inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
2013 inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
2017 inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
2021 inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
2025 inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
2029 inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
2033 inline void BlendBarrier(void)
2038 inline void AddUniformCallToTraceStack(GLint location, const std::string& value)
2040 std::string name = "<not found>";
2041 bool matched = false;
2043 UniformIDMap& map = mUniforms[mCurrentProgram];
2044 for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
2046 if(it->second == location)
2056 mSetUniformTrace.PushCall(name, value);
2060 public: // TEST FUNCTIONS
2061 inline void SetCompileStatus(GLuint value)
2063 mCompileStatus = value;
2065 inline void SetLinkStatus(GLuint value)
2067 mLinkStatus = value;
2069 inline void SetAttribLocations(std::vector<std::string> locs)
2073 inline void SetGetErrorResult(GLenum result)
2075 mGetErrorResult = result;
2077 inline void SetGetStringResult(GLubyte* result)
2079 mGetStringResult = result;
2081 inline void SetIsBufferResult(GLboolean result)
2083 mIsBufferResult = result;
2085 inline void SetIsEnabledResult(GLboolean result)
2087 mIsEnabledResult = result;
2089 inline void SetIsFramebufferResult(GLboolean result)
2091 mIsFramebufferResult = result;
2093 inline void SetIsProgramResult(GLboolean result)
2095 mIsProgramResult = result;
2097 inline void SetIsRenderbufferResult(GLboolean result)
2099 mIsRenderbufferResult = result;
2101 inline void SetIsShaderResult(GLboolean result)
2103 mIsShaderResult = result;
2105 inline void SetIsTextureResult(GLboolean result)
2107 mIsTextureResult = result;
2109 inline void SetCheckFramebufferStatusResult(GLenum result)
2111 mCheckFramebufferStatusResult = result;
2113 inline void SetNumBinaryFormats(GLint numFormats)
2115 mNumBinaryFormats = numFormats;
2117 inline void SetBinaryFormats(GLint binaryFormats)
2119 mBinaryFormats = binaryFormats;
2121 inline void SetProgramBinaryLength(GLint length)
2123 mProgramBinaryLength = length;
2126 inline bool GetVertexAttribArrayState(GLuint index)
2128 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2133 return mVertexAttribArrayState[index];
2135 inline void ClearVertexAttribArrayChanged()
2137 mVertexAttribArrayChanged = false;
2139 inline bool GetVertexAttribArrayChanged()
2141 return mVertexAttribArrayChanged;
2144 //Methods for CullFace verification
2145 inline void EnableCullFaceCallTrace(bool enable)
2147 mCullFaceTrace.Enable(enable);
2149 inline void ResetCullFaceCallStack()
2151 mCullFaceTrace.Reset();
2153 inline TraceCallStack& GetCullFaceTrace()
2155 return mCullFaceTrace;
2158 //Methods for Enable/Disable call verification
2159 inline void EnableEnableDisableCallTrace(bool enable)
2161 mEnableDisableTrace.Enable(enable);
2163 inline void ResetEnableDisableCallStack()
2165 mEnableDisableTrace.Reset();
2167 inline TraceCallStack& GetEnableDisableTrace()
2169 return mEnableDisableTrace;
2172 //Methods for Shader verification
2173 inline void EnableShaderCallTrace(bool enable)
2175 mShaderTrace.Enable(enable);
2177 inline void ResetShaderCallStack()
2179 mShaderTrace.Reset();
2181 inline TraceCallStack& GetShaderTrace()
2183 return mShaderTrace;
2186 //Methods for Texture verification
2187 inline void EnableTextureCallTrace(bool enable)
2189 mTextureTrace.Enable(enable);
2191 inline void ResetTextureCallStack()
2193 mTextureTrace.Reset();
2195 inline TraceCallStack& GetTextureTrace()
2197 return mTextureTrace;
2200 //Methods for Texture verification
2201 inline void EnableTexParameterCallTrace(bool enable)
2203 mTexParameterTrace.Enable(enable);
2205 inline void ResetTexParameterCallStack()
2207 mTexParameterTrace.Reset();
2209 inline TraceCallStack& GetTexParameterTrace()
2211 return mTexParameterTrace;
2214 //Methods for Draw verification
2215 inline void EnableDrawCallTrace(bool enable)
2217 mDrawTrace.Enable(enable);
2219 inline void ResetDrawCallStack()
2223 inline TraceCallStack& GetDrawTrace()
2228 //Methods for Depth function verification
2229 inline void EnableDepthFunctionCallTrace(bool enable)
2231 mDepthFunctionTrace.Enable(enable);
2233 inline void ResetDepthFunctionCallStack()
2235 mDepthFunctionTrace.Reset();
2237 inline TraceCallStack& GetDepthFunctionTrace()
2239 return mDepthFunctionTrace;
2242 //Methods for Stencil function verification
2243 inline void EnableStencilFunctionCallTrace(bool enable)
2245 mStencilFunctionTrace.Enable(enable);
2247 inline void ResetStencilFunctionCallStack()
2249 mStencilFunctionTrace.Reset();
2251 inline TraceCallStack& GetStencilFunctionTrace()
2253 return mStencilFunctionTrace;
2256 //Methods for Scissor verification
2257 inline void EnableScissorCallTrace(bool enable)
2259 mScissorTrace.Enable(enable);
2261 inline void ResetScissorCallStack()
2263 mScissorTrace.Reset();
2265 inline TraceCallStack& GetScissorTrace()
2267 return mScissorTrace;
2270 //Methods for Uniform function verification
2271 inline void EnableSetUniformCallTrace(bool enable)
2273 mSetUniformTrace.Enable(enable);
2275 inline void ResetSetUniformCallStack()
2277 mSetUniformTrace.Reset();
2279 inline TraceCallStack& GetSetUniformTrace()
2281 return mSetUniformTrace;
2284 //Methods for Viewport verification
2285 inline void EnableViewportCallTrace(bool enable)
2287 mViewportTrace.Enable(enable);
2289 inline void ResetViewportCallStack()
2291 mViewportTrace.Reset();
2293 inline TraceCallStack& GetViewportTrace()
2295 return mViewportTrace;
2297 inline TraceCallStack& GetBufferTrace()
2299 return mBufferTrace;
2302 template<typename T>
2303 inline bool GetUniformValue(const char* name, T& value) const
2305 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2306 program_it != mUniforms.end();
2309 const UniformIDMap& uniformIDs = program_it->second;
2311 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2312 if(uniform_it != uniformIDs.end())
2314 // found one matching uniform name, lets check the value...
2315 GLuint programId = program_it->first;
2316 GLint uniformId = uniform_it->second;
2318 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2319 return mProgramUniforms.GetUniformValue(programId, uniformId, value);
2325 template<typename T>
2326 inline bool CheckUniformValue(const char* name, const T& value) const
2328 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2329 program_it != mUniforms.end();
2332 const UniformIDMap& uniformIDs = program_it->second;
2334 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2335 if(uniform_it != uniformIDs.end())
2337 // found one matching uniform name, lets check the value...
2338 GLuint programId = program_it->first;
2339 GLint uniformId = uniform_it->second;
2341 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2342 if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
2344 // the value matches
2350 fprintf(stderr, "%s Not found, printing possible values:\n", name);
2351 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2352 program_it != mUniforms.end();
2355 const UniformIDMap& uniformIDs = program_it->second;
2357 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2358 if(uniform_it != uniformIDs.end())
2360 // found one matching uniform name, lets check the value...
2361 GLuint programId = program_it->first;
2362 GLint uniformId = uniform_it->second;
2364 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
2366 if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
2368 std::stringstream out;
2369 out << "Program: " << programId << ", " << uniform_it->first << ": " << origValue;
2370 fprintf(stderr, "%s\n", out.str().c_str());
2377 template<typename T>
2378 inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
2380 const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
2381 return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
2384 inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
2386 for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
2387 program_it != mUniforms.end();
2390 const UniformIDMap& uniformIDs = program_it->second;
2392 UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
2393 if(uniform_it != uniformIDs.end())
2395 programId = program_it->first;
2396 uniformId = uniform_it->second;
2403 inline void SetCustomUniforms(std::vector<UniformData>& customUniformData)
2405 mCustomUniformData = customUniformData;
2408 inline GLuint GetLastShaderCompiled() const
2410 return mLastShaderCompiled;
2413 inline GLuint GetLastProgramCreated() const
2415 return mLastProgramIdUsed;
2418 inline GLbitfield GetLastClearMask() const
2420 return mLastClearBitMask;
2425 ATTRIB_UNKNOWN = -1,
2430 ATTRIB_BONE_WEIGHTS,
2431 ATTRIB_BONE_INDICES,
2435 struct ScissorParams
2451 // Methods to check scissor tests
2452 inline const ScissorParams& GetScissorParams() const
2454 return mScissorParams;
2457 struct ColorMaskParams
2473 inline bool GetProgramBinaryCalled() const
2475 return mGetProgramBinaryCalled;
2478 inline unsigned int GetClearCountCalled() const
2483 inline const ColorMaskParams& GetColorMaskParams() const
2485 return mColorMaskParams;
2488 typedef std::vector<size_t> BufferDataCalls;
2489 inline const BufferDataCalls& GetBufferDataCalls() const
2491 return mBufferDataCalls;
2493 inline void ResetBufferDataCalls()
2495 mBufferDataCalls.clear();
2498 typedef std::vector<size_t> BufferSubDataCalls;
2499 inline const BufferSubDataCalls& GetBufferSubDataCalls() const
2501 return mBufferSubDataCalls;
2503 inline void ResetBufferSubDataCalls()
2505 mBufferSubDataCalls.clear();
2509 GLuint mCurrentProgram;
2510 GLuint mCompileStatus;
2511 BufferDataCalls mBufferDataCalls;
2512 BufferSubDataCalls mBufferSubDataCalls;
2513 GLvoid* mMappedBuffer{nullptr};
2515 GLenum mGetErrorResult;
2516 GLubyte* mGetStringResult;
2517 GLboolean mIsBufferResult;
2518 GLboolean mIsEnabledResult;
2519 GLboolean mIsFramebufferResult;
2520 GLboolean mIsProgramResult;
2521 GLboolean mIsRenderbufferResult;
2522 GLboolean mIsShaderResult;
2523 GLboolean mIsTextureResult;
2524 GLenum mActiveTextureUnit;
2525 GLenum mCheckFramebufferStatusResult;
2526 GLint mFramebufferStatus;
2527 GLenum mFramebufferDepthAttached;
2528 GLenum mFramebufferStencilAttached;
2529 GLenum mFramebufferDepthStencilAttached;
2530 GLuint mFramebufferColorAttachmentCount;
2531 GLuint mFrameBufferColorStatus;
2532 GLuint mFramebufferDepthAttachmentCount;
2533 GLuint mFramebufferStencilAttachmentCount;
2534 GLuint mFramebufferDepthStencilAttachmentCount;
2535 GLint mNumBinaryFormats;
2536 GLint mBinaryFormats;
2537 GLint mProgramBinaryLength;
2538 bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
2539 bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
2540 bool mGetProgramBinaryCalled;
2541 typedef std::map<GLuint, std::string> ShaderSourceMap;
2542 ShaderSourceMap mShaderSources;
2543 std::vector<std::string> mAttribLocs; // should be bound to shader
2544 GLuint mLastShaderCompiled;
2545 GLbitfield mLastClearBitMask;
2546 Vector4 mLastClearColor;
2547 unsigned int mClearCount;
2549 Vector4 mLastBlendColor;
2550 GLenum mLastBlendEquationRgb;
2551 GLenum mLastBlendEquationAlpha;
2552 GLenum mLastBlendFuncSrcRgb;
2553 GLenum mLastBlendFuncDstRgb;
2554 GLenum mLastBlendFuncSrcAlpha;
2555 GLenum mLastBlendFuncDstAlpha;
2557 GLboolean mLastDepthMask;
2559 // Data for manipulating the IDs returned by GenTextures
2560 GLuint mLastAutoTextureIdUsed;
2561 GLuint mNumGeneratedTextures;
2562 std::vector<GLuint> mNextTextureIds;
2563 std::vector<GLuint> mDeletedTextureIds;
2564 std::vector<GLuint> mBoundTextures;
2566 struct ActiveTextureType
2568 std::vector<GLuint> mBoundTextures;
2571 ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
2573 TraceCallStack mBufferTrace;
2574 TraceCallStack mCullFaceTrace;
2575 TraceCallStack mEnableDisableTrace;
2576 TraceCallStack mShaderTrace;
2577 TraceCallStack mTextureTrace;
2578 TraceCallStack mTexParameterTrace;
2579 TraceCallStack mDrawTrace;
2580 TraceCallStack mDepthFunctionTrace;
2581 TraceCallStack mStencilFunctionTrace;
2582 TraceCallStack mScissorTrace;
2583 TraceCallStack mSetUniformTrace;
2584 TraceCallStack mViewportTrace;
2586 // Shaders & Uniforms
2587 GLuint mLastShaderIdUsed;
2588 GLuint mLastProgramIdUsed{0u};
2589 GLuint mLastUniformIdUsed;
2590 typedef std::map<std::string, GLint> UniformIDMap;
2591 typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
2592 ProgramUniformMap mUniforms;
2593 std::vector<ActiveUniform> mActiveUniforms;
2594 std::vector<UniformData> mCustomUniformData{};
2596 template<typename T>
2597 struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
2600 typedef std::map<GLint, T> UniformValueMap;
2601 typedef std::map<GLuint, UniformValueMap> Map;
2603 bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
2610 typename Map::iterator it = Map::find(program);
2611 if(it == Map::end())
2613 // if its the first uniform for this program add it
2614 std::pair<typename Map::iterator, bool> result =
2615 Map::insert(typename Map::value_type(program, UniformValueMap()));
2619 UniformValueMap& uniforms = it->second;
2620 uniforms[uniform] = value;
2625 bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
2628 if(GetUniformValue(program, uniform, uniformValue))
2630 return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
2636 bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
2643 typename Map::const_iterator it = Map::find(program);
2644 if(it == Map::end())
2646 // Uniform values always initialised as 0
2651 const UniformValueMap& uniforms = it->second;
2652 typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
2653 if(it2 == uniforms.end())
2655 // Uniform values always initialised as 0
2659 value = it2->second;
2666 ProgramUniformValue<int> mProgramUniforms1i;
2667 ProgramUniformValue<float> mProgramUniforms1f;
2668 ProgramUniformValue<Vector2> mProgramUniforms2f;
2669 ProgramUniformValue<Vector3> mProgramUniforms3f;
2670 ProgramUniformValue<Vector4> mProgramUniforms4f;
2671 ProgramUniformValue<Matrix> mProgramUniformsMat4;
2672 ProgramUniformValue<Matrix3> mProgramUniformsMat3;
2674 inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
2676 return mProgramUniforms1i;
2678 inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
2680 return mProgramUniforms1f;
2682 inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
2684 return mProgramUniforms2f;
2686 inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
2688 return mProgramUniforms3f;
2690 inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
2692 return mProgramUniforms4f;
2694 inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
2696 return mProgramUniformsMat4;
2698 inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
2700 return mProgramUniformsMat3;
2702 inline void SetVertexAttribArray(GLuint index, bool state)
2704 if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
2709 mVertexAttribArrayState[index] = state;
2710 mVertexAttribArrayChanged = true;
2713 ScissorParams mScissorParams;
2714 ColorMaskParams mColorMaskParams;
2718 inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
2724 inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
2730 inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
2732 return Vector2::ZERO;
2736 inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
2738 return Vector3::ZERO;
2742 inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
2744 return Vector4::ZERO;
2748 inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
2754 inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
2756 return Matrix3(Matrix());
2761 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2762 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2764 #endif // TEST_GL_ABSTRACTION_H