Dali 3D User Interface Engine
test-gl-abstraction.h
Go to the documentation of this file.
1 #ifndef __TEST_GL_ABSTRACTION_H__
2 #define __TEST_GL_ABSTRACTION_H__
3 
4 /*
5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
6  *
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
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
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.
18  *
19  */
20 
21 // EXTERNAL INCLUDES
22 #include <sstream>
23 #include <string>
24 #include <cstring>
25 #include <map>
26 #include <cstdio>
27 #include <cstring> // for strcmp
28 
29 // INTERNAL INCLUDES
34 #include "test-trace-call-stack.h"
35 
36 namespace Dali
37 {
38 
39 static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 64;
41 {
42  "aPosition", // ATTRIB_POSITION
43  "aNormal", // ATTRIB_NORMAL
44  "aTexCoord", // ATTRIB_TEXCOORD
45  "aColor", // ATTRIB_COLOR
46  "aBoneWeights", // ATTRIB_BONE_WEIGHTS
47  "aBoneIndices" // ATTRIB_BONE_INDICES
48 };
49 
51 {
52 public:
55  void Initialize();
56 
57  void PreRender();
58  void PostRender();
59 
60  /* OpenGL ES 2.0 */
61 
62  inline void ActiveTexture( GLenum textureUnit )
63  {
64  mActiveTextureUnit = textureUnit - GL_TEXTURE0;
65  }
66 
67  inline GLenum GetActiveTextureUnit() const
68  {
69  return mActiveTextureUnit + GL_TEXTURE0;
70  }
71 
72  inline void AttachShader( GLuint program, GLuint shader )
73  {
74  std::stringstream out;
75  out << program << ", " << shader;
76  mShaderTrace.PushCall("AttachShader", out.str());
77  }
78 
79  inline void BindAttribLocation( GLuint program, GLuint index, const char* name )
80  {
81  }
82 
83  inline void BindBuffer( GLenum target, GLuint buffer )
84  {
85  }
86 
87  inline void BindFramebuffer( GLenum target, GLuint framebuffer )
88  {
89  //Add 010 bit;
90  mFramebufferStatus |= 2;
91  }
92 
93  inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
94  {
95  }
96 
101  inline const std::vector<GLuint>& GetBoundTextures() const
102  {
103  return mBoundTextures;
104  }
105 
111  inline const std::vector<GLuint>& GetBoundTextures( GLuint activeTextureUnit ) const
112  {
113  return mActiveTextures[ activeTextureUnit - GL_TEXTURE0 ].mBoundTextures;
114  }
115 
119  inline void ClearBoundTextures()
120  {
121  mBoundTextures.clear();
122 
123  for( unsigned int i=0; i<MIN_TEXTURE_UNIT_LIMIT; ++i )
124  {
125  mActiveTextures[ i ].mBoundTextures.clear();
126  }
127  }
128 
129  inline void BindTexture( GLenum target, GLuint texture )
130  {
131  // Record the bound textures for future checks
132  if( texture )
133  {
134  mBoundTextures.push_back( texture );
135 
136  if( mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT )
137  {
138  mActiveTextures[ mActiveTextureUnit ].mBoundTextures.push_back( texture );
139  }
140  }
141 
142  std::stringstream out;
143  out << target << ", " << texture;
144  mTextureTrace.PushCall("BindTexture", out.str());
145  }
146 
147  inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
148  {
149  mLastBlendColor.r = red;
150  mLastBlendColor.g = green;
151  mLastBlendColor.b = blue;
152  mLastBlendColor.a = alpha;
153  }
154 
155  inline const Vector4& GetLastBlendColor() const
156  {
157  return mLastBlendColor;
158  }
159 
160  inline void BlendEquation( GLenum mode )
161  {
162  mLastBlendEquationRgb = mode;
163  mLastBlendEquationAlpha = mode;
164  }
165 
166  inline void BlendEquationSeparate( GLenum modeRgb, GLenum modeAlpha )
167  {
168  mLastBlendEquationRgb = modeRgb;
169  mLastBlendEquationAlpha = modeAlpha;
170  }
171 
172  inline GLenum GetLastBlendEquationRgb() const
173  {
174  return mLastBlendEquationRgb;
175  }
176 
177  inline GLenum GetLastBlendEquationAlpha() const
178  {
179  return mLastBlendEquationAlpha;
180  }
181 
182  inline void BlendFunc(GLenum sfactor, GLenum dfactor)
183  {
184  mLastBlendFuncSrcRgb = sfactor;
185  mLastBlendFuncDstRgb = dfactor;
186  mLastBlendFuncSrcAlpha = sfactor;
187  mLastBlendFuncDstAlpha = dfactor;
188  }
189 
190  inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
191  {
192  mLastBlendFuncSrcRgb = srcRGB;
193  mLastBlendFuncDstRgb = dstRGB;
194  mLastBlendFuncSrcAlpha = srcAlpha;
195  mLastBlendFuncDstAlpha = dstAlpha;
196  }
197 
198  inline GLenum GetLastBlendFuncSrcRgb() const
199  {
200  return mLastBlendFuncSrcRgb;
201  }
202 
203  inline GLenum GetLastBlendFuncDstRgb() const
204  {
205  return mLastBlendFuncDstRgb;
206  }
207 
208  inline GLenum GetLastBlendFuncSrcAlpha() const
209  {
210  return mLastBlendFuncSrcAlpha;
211  }
212 
213  inline GLenum GetLastBlendFuncDstAlpha() const
214  {
215  return mLastBlendFuncDstAlpha;
216  }
217 
218  inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
219  {
220  mBufferDataCalls.push_back(size);
221  }
222 
223  inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
224  {
225  mBufferSubDataCalls.push_back(size);
226  }
227 
228  inline GLenum CheckFramebufferStatus(GLenum target)
229  {
230  //If it has the three last bits set to 1 - 111, then the three minimum functions to create a
231  //Framebuffer texture have been called
232  if( mFramebufferStatus == 7 )
233  {
235  }
236 
237  return mCheckFramebufferStatusResult;
238  }
239 
240  inline GLenum CheckFramebufferColorAttachment()
241  {
242  return mFramebufferColorAttached;
243  }
244 
245  inline GLenum CheckFramebufferDepthAttachment()
246  {
247  return mFramebufferDepthAttached;
248  }
249 
250  inline GLenum CheckFramebufferStencilAttachment()
251  {
252  return mFramebufferStencilAttached;
253  }
254 
255  inline void Clear(GLbitfield mask)
256  {
257  mClearCount++;
258  mLastClearBitMask = mask;
259  }
260 
261  inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
262  {
263  }
264 
265  inline void ClearDepthf(GLclampf depth)
266  {
267  }
268 
269  inline void ClearStencil(GLint s)
270  {
271  }
272 
273  inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
274  {
275  }
276 
277  inline void CompileShader(GLuint shader)
278  {
279  std::stringstream out;
280  out << shader;
281  mShaderTrace.PushCall("CompileShader", out.str());
282  }
283 
284  inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
285  {
286  }
287 
288  inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
289  {
290  }
291 
292  inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
293  {
294  }
295 
296  inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
297  {
298  }
299 
300  inline GLuint CreateProgram(void)
301  {
302  mShaderTrace.PushCall("CreateProgram", "");
303 
304  ++mLastProgramIdUsed;
305  mUniforms[mLastProgramIdUsed] = UniformIDMap();
306  return mLastProgramIdUsed;
307  }
308 
309  inline GLuint CreateShader(GLenum type)
310  {
311  std::stringstream out;
312  out << type;
313  mShaderTrace.PushCall("CreateShader", out.str());
314 
315  return ++mLastShaderIdUsed;
316  }
317 
318  inline void CullFace(GLenum mode)
319  {
320  std::stringstream out;
321  out << mode;
322  mCullFaceTrace.PushCall("CullFace", out.str());
323  }
324 
325  inline void DeleteBuffers(GLsizei n, const GLuint* buffers)
326  {
327  }
328 
329  inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
330  {
331  }
332 
333  inline void DeleteProgram(GLuint program)
334  {
335  std::stringstream out;
336  out << program;
337  mShaderTrace.PushCall("DeleteProgram", out.str());
338  }
339 
340  inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
341  {
342  }
343 
344  inline void DeleteShader(GLuint shader)
345  {
346  std::stringstream out;
347  out << shader;
348  mShaderTrace.PushCall("DeleteShader", out.str());
349  }
350 
351  inline void DeleteTextures(GLsizei n, const GLuint* textures)
352  {
353  std::stringstream out;
354  out << n << ", " << textures << " = [";
355 
356  for(GLsizei i=0; i<n; i++)
357  {
358  out << textures[i] << ", ";
359  mDeletedTextureIds.push_back(textures[i]);
360  }
361  out << "]";
362  mTextureTrace.PushCall("DeleteTextures", out.str());
363  }
364 
365  inline bool CheckNoTexturesDeleted()
366  {
367  return mDeletedTextureIds.size() == 0;
368  }
369 
370  inline bool CheckTextureDeleted( GLuint textureId )
371  {
372  bool found = false;
373 
374  for(std::vector<GLuint>::iterator iter=mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
375  {
376  if(*iter == textureId)
377  {
378  found = true;
379  break;
380  }
381  }
382  return found;
383  }
384 
385  inline void ClearDeletedTextures()
386  {
387  mDeletedTextureIds.clear();
388  }
389 
390  inline void DepthFunc(GLenum func)
391  {
392  }
393 
394  inline void DepthMask(GLboolean flag)
395  {
396  }
397 
398  inline void DepthRangef(GLclampf zNear, GLclampf zFar)
399  {
400  }
401 
402  inline void DetachShader(GLuint program, GLuint shader)
403  {
404  std::stringstream out;
405  out << program << ", " << shader;
406  mShaderTrace.PushCall("DetachShader", out.str());
407  }
408 
409  inline void Disable(GLenum cap)
410  {
411  std::stringstream out;
412  out << cap;
413  mEnableDisableTrace.PushCall("Disable", out.str());
414  }
415 
416  inline void DisableVertexAttribArray(GLuint index)
417  {
418  SetVertexAttribArray( index, false );
419  }
420 
421  inline void DrawArrays(GLenum mode, GLint first, GLsizei count)
422  {
423  std::stringstream out;
424  out << mode << ", " << first << ", " << count;
425  mDrawTrace.PushCall("DrawArrays", out.str());
426  }
427 
428  inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
429  {
430  std::stringstream out;
431  out << mode << ", " << count << ", " << type << ", indices";
432  mDrawTrace.PushCall("DrawElements", out.str());
433  }
434 
435  inline void Enable(GLenum cap)
436  {
437  std::stringstream out;
438  out << cap;
439  mEnableDisableTrace.PushCall("Enable", out.str());
440  }
441 
442  inline void EnableVertexAttribArray(GLuint index)
443  {
444  SetVertexAttribArray( index, true);
445  }
446 
447  inline void Finish(void)
448  {
449  }
450 
451  inline void Flush(void)
452  {
453  }
454 
455  inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
456  {
457  if (attachment == GL_DEPTH_ATTACHMENT)
458  {
459  mFramebufferDepthAttached = true;
460  }
461  else if (attachment == GL_STENCIL_ATTACHMENT)
462  {
463  mFramebufferStencilAttached = true;
464  }
465  }
466 
467  inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
468  {
469  //Add 100 bit;
470  mFramebufferStatus |= 4;
471 
472  //We check 4 attachment colors
473  if ((attachment == GL_COLOR_ATTACHMENT0) || (attachment == GL_COLOR_ATTACHMENT1) || (attachment == GL_COLOR_ATTACHMENT2) || (attachment == GL_COLOR_ATTACHMENT4))
474  {
475  mFramebufferColorAttached = true;
476  }
477  }
478 
479  inline void FrontFace(GLenum mode)
480  {
481  }
482 
483  inline void GenBuffers(GLsizei n, GLuint* buffers)
484  {
485  // avoids an assert in GpuBuffers
486  *buffers = 1u;
487  }
488 
489  inline void GenerateMipmap(GLenum target)
490  {
491  }
492 
493  inline void GenFramebuffers(GLsizei n, GLuint* framebuffers)
494  {
495  for( int i = 0; i < n; i++ )
496  {
497  framebuffers[i] = i + 1;
498  }
499 
500  //Add 001 bit, this function needs to be called the first one in the chain
501  mFramebufferStatus = 1;
502  }
503 
504  inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
505  {
506  for( int i = 0; i < n; i++ )
507  {
508  renderbuffers[i] = i + 1;
509  }
510  }
511 
516  inline void SetNextTextureIds( const std::vector<GLuint>& ids )
517  {
518  mNextTextureIds = ids;
519  }
520 
521  inline const std::vector<GLuint>& GetNextTextureIds()
522  {
523  return mNextTextureIds;
524  }
525 
526  inline void GenTextures(GLsizei n, GLuint* textures)
527  {
528  for( int i=0; i<n; ++i )
529  {
530  if( !mNextTextureIds.empty() )
531  {
532  *(textures+i) = mNextTextureIds[0];
533  mNextTextureIds.erase( mNextTextureIds.begin() );
534  }
535  else
536  {
537  *(textures+i) = ++mLastAutoTextureIdUsed;
538  }
539  }
540 
541  std::stringstream out;
542  for(int i=0; i<n; i++)
543  {
544  out << textures[i];
545  if(i<n-1)
546  {
547  out << ", ";
548  }
549  }
550  mTextureTrace.PushCall("GenTextures", out.str());
551  }
552 
553  inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
554  {
555  }
556 
557  inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
558  {
559  }
560 
561  inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
562  {
563  }
564 
565  inline int GetAttribLocation(GLuint program, const char* name)
566  {
567  std::string attribName(name);
568 
569  for( unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i )
570  {
571  if( mStdAttribs[i] == attribName )
572  {
573  return i;
574  }
575  }
576 
577  // 0 is a valid location
578  return 0;
579  }
580 
581  inline void GetBooleanv(GLenum pname, GLboolean* params)
582  {
583  }
584 
585  inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
586  {
587  }
588 
589  inline GLenum GetError(void)
590  {
591  return mGetErrorResult;
592  }
593 
594  inline void GetFloatv(GLenum pname, GLfloat* params)
595  {
596  }
597 
598  inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
599  {
600  }
601 
602  inline void GetIntegerv(GLenum pname, GLint* params)
603  {
604  switch( pname )
605  {
606  case GL_MAX_TEXTURE_SIZE:
607  *params = 2048;
608  break;
610  *params = 8;
611  break;
613  *params = mNumBinaryFormats;
614  break;
616  *params = mBinaryFormats;
617  break;
618  }
619  }
620 
621  inline void GetProgramiv(GLuint program, GLenum pname, GLint* params)
622  {
623  switch( pname ) {
624  case GL_LINK_STATUS:
625  *params = mLinkStatus;
626  break;
628  *params = mProgramBinaryLength;
629  break;
630  }
631  }
632 
633  inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
634  {
635  }
636 
637 
638  inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
639  {
640  }
641 
642  inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params)
643  {
644  switch( pname ) {
645  case GL_COMPILE_STATUS:
646  *params = mCompileStatus;
647  break;
648  }
649  }
650 
651  inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
652  {
653  }
654 
655  inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
656  {
657  }
658 
659  inline const GLubyte* GetString(GLenum name)
660  {
661  return mGetStringResult;
662  }
663 
664  inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
665  {
666  }
667 
668  inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
669  {
670  }
671 
672  inline void GetUniformfv(GLuint program, GLint location, GLfloat* params)
673  {
674  }
675 
676  inline void GetUniformiv(GLuint program, GLint location, GLint* params)
677  {
678  }
679 
680  inline GLint GetUniformLocation(GLuint program, const char* name)
681  {
682  ProgramUniformMap::iterator it = mUniforms.find(program);
683  if( it == mUniforms.end() )
684  {
685  // Not a valid program ID
686  mGetErrorResult = GL_INVALID_OPERATION;
687  return -1;
688  }
689 
690  UniformIDMap& uniformIDs = it->second;
691  UniformIDMap::iterator it2 = uniformIDs.find( name );
692  if( it2 == uniformIDs.end() )
693  {
694  // Uniform not found, so add it...
695  uniformIDs[name] = ++mLastUniformIdUsed;
696  return mLastUniformIdUsed;
697  }
698 
699  return it2->second;
700  }
701 
702  inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
703  {
704  }
705 
706  inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
707  {
708  }
709 
710  inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
711  {
712  }
713 
714  inline void Hint(GLenum target, GLenum mode)
715  {
716  }
717 
718  inline GLboolean IsBuffer(GLuint buffer)
719  {
720  return mIsBufferResult;
721  }
722 
723  inline GLboolean IsEnabled(GLenum cap)
724  {
725  return mIsEnabledResult;
726  }
727 
728  inline GLboolean IsFramebuffer(GLuint framebuffer)
729  {
730  return mIsFramebufferResult;
731  }
732 
733  inline GLboolean IsProgram(GLuint program)
734  {
735  return mIsProgramResult;
736  }
737 
738  inline GLboolean IsRenderbuffer(GLuint renderbuffer)
739  {
740  return mIsRenderbufferResult;
741  }
742 
743  inline GLboolean IsShader(GLuint shader)
744  {
745  return mIsShaderResult;
746  }
747 
748  inline GLboolean IsTexture(GLuint texture)
749  {
750  return mIsTextureResult;
751  }
752 
753  inline void LineWidth(GLfloat width)
754  {
755  }
756 
757  inline void LinkProgram(GLuint program)
758  {
759  std::stringstream out;
760  out << program;
761  mShaderTrace.PushCall("LinkProgram", out.str());
762  }
763 
764  inline void PixelStorei(GLenum pname, GLint param)
765  {
766  }
767 
768  inline void PolygonOffset(GLfloat factor, GLfloat units)
769  {
770  }
771 
772  inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
773  {
774  }
775 
776  inline void ReleaseShaderCompiler(void)
777  {
778  }
779 
780  inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
781  {
782  }
783 
784  inline void SampleCoverage(GLclampf value, GLboolean invert)
785  {
786  }
787 
788  inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
789  {
790  mScissorParams.x = x;
791  mScissorParams.y = y;
792  mScissorParams.width = width;
793  mScissorParams.height = height;
794  }
795 
796  inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
797  {
798  }
799 
800  inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
801  {
802  std::string stringBuilder;
803  for(int i = 0; i < count; ++i)
804  {
805  stringBuilder += string[i];
806  }
807  mShaderSources[shader] = stringBuilder;
808  mLastShaderCompiled = shader;
809  }
810 
811  inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
812  {
813  const std::string shaderSource = mShaderSources[shader];
814  if( static_cast<int>(shaderSource.length()) < bufsize )
815  {
816  strcpy(source, shaderSource.c_str());
817  *length = shaderSource.length();
818  }
819  else
820  {
821  *length = bufsize -1;
822  strncpy(source, shaderSource.c_str(), *length);
823  source[*length] = 0x0;
824  }
825  }
826 
827  inline std::string GetShaderSource(GLuint shader)
828  {
829  return mShaderSources[shader];
830  }
831 
832  inline void StencilFunc(GLenum func, GLint ref, GLuint mask)
833  {
834  }
835 
836  inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
837  {
838  }
839 
840  inline void StencilMask(GLuint mask)
841  {
842  }
843 
844  inline void StencilMaskSeparate(GLenum face, GLuint mask)
845  {
846  }
847 
848  inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
849  {
850  }
851 
852  inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
853  {
854  }
855 
856  inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
857  {
858  std::stringstream out;
859  out << width << ", " << height;
860  mTextureTrace.PushCall("TexImage2D", out.str());
861  }
862 
863  inline void TexParameterf(GLenum target, GLenum pname, GLfloat param)
864  {
865  std::stringstream out;
866  out << target << ", " << pname << ", " << param;
867  mTexParamaterTrace.PushCall("TexParameterf", out.str());
868  }
869 
870  inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
871  {
872  std::stringstream out;
873  out << target << ", " << pname << ", " << params[0];
874  mTexParamaterTrace.PushCall("TexParameterfv", out.str());
875  }
876 
877  inline void TexParameteri(GLenum target, GLenum pname, GLint param)
878  {
879  std::stringstream out;
880  out << target << ", " << pname << ", " << param;
881  mTexParamaterTrace.PushCall("TexParameteri", out.str());
882  }
883 
884  inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
885  {
886  std::stringstream out;
887  out << target << ", " << pname << ", " << params[0];
888  mTexParamaterTrace.PushCall("TexParameteriv", out.str());
889  }
890 
891  inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
892  {
893  std::stringstream out;
894  out << xoffset << ", " << yoffset << ", " << width << ", " << height;
895  mTextureTrace.PushCall("TexSubImage2D", out.str());
896  }
897 
898  inline void Uniform1f(GLint location, GLfloat x)
899  {
900  if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, x ) )
901  {
902  mGetErrorResult = GL_INVALID_OPERATION;
903  }
904  }
905 
906  inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v)
907  {
908  for( int i = 0; i < count; ++i )
909  {
910  if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, v[i] ) )
911  {
912  mGetErrorResult = GL_INVALID_OPERATION;
913  break;
914  }
915  }
916  }
917 
918  inline void Uniform1i(GLint location, GLint x)
919  {
920  if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram, location, x ) )
921  {
922  mGetErrorResult = GL_INVALID_OPERATION;
923  }
924  }
925 
926  inline void Uniform1iv(GLint location, GLsizei count, const GLint* v)
927  {
928  for( int i = 0; i < count; ++i )
929  {
930  if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram,
931  location,
932  v[i] ) )
933  {
934  mGetErrorResult = GL_INVALID_OPERATION;
935  break;
936  }
937  }
938  }
939 
940  inline void Uniform2f(GLint location, GLfloat x, GLfloat y)
941  {
942  if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
943  location,
944  Vector2( x, y ) ) )
945  {
946  mGetErrorResult = GL_INVALID_OPERATION;
947  }
948  }
949 
950  inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v)
951  {
952  for( int i = 0; i < count; ++i )
953  {
954  if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
955  location,
956  Vector2( v[2*i], v[2*i+1] ) ) )
957  {
958  mGetErrorResult = GL_INVALID_OPERATION;
959  break;
960  }
961  }
962  }
963 
964  inline void Uniform2i(GLint location, GLint x, GLint y)
965  {
966  }
967 
968  inline void Uniform2iv(GLint location, GLsizei count, const GLint* v)
969  {
970  }
971 
972  inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
973  {
974  if( ! mProgramUniforms3f.SetUniformValue( mCurrentProgram,
975  location,
976  Vector3( x, y, z ) ) )
977  {
978  mGetErrorResult = GL_INVALID_OPERATION;
979  }
980  }
981 
982  inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v)
983  {
984  for( int i = 0; i < count; ++i )
985  {
986  if( ! mProgramUniforms3f.SetUniformValue(
987  mCurrentProgram,
988  location,
989  Vector3( v[3*i], v[3*i+1], v[3*i+2] ) ) )
990  {
991  mGetErrorResult = GL_INVALID_OPERATION;
992  break;
993  }
994  }
995  }
996 
997  inline void Uniform3i(GLint location, GLint x, GLint y, GLint z)
998  {
999  }
1000 
1001  inline void Uniform3iv(GLint location, GLsizei count, const GLint* v)
1002  {
1003  }
1004 
1005  inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1006  {
1007  if( ! mProgramUniforms4f.SetUniformValue( mCurrentProgram,
1008  location,
1009  Vector4( x, y, z, w ) ) )
1010  {
1011  mGetErrorResult = GL_INVALID_OPERATION;
1012  }
1013  }
1014 
1015  inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v)
1016  {
1017  for( int i = 0; i < count; ++i )
1018  {
1019  if( ! mProgramUniforms4f.SetUniformValue(
1020  mCurrentProgram,
1021  location,
1022  Vector4( v[4*i], v[4*i+1], v[4*i+2], v[4*i+3] ) ) )
1023  {
1024  mGetErrorResult = GL_INVALID_OPERATION;
1025  break;
1026  }
1027  }
1028  }
1029 
1030  inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
1031  {
1032  }
1033 
1034  inline void Uniform4iv(GLint location, GLsizei count, const GLint* v)
1035  {
1036  }
1037 
1038  inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1039  {
1040  }
1041 
1042  inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1043  {
1044  for( int i = 0; i < count; ++i )
1045  {
1046  if( ! mProgramUniformsMat3.SetUniformValue(
1047  mCurrentProgram,
1048  location,
1049  Matrix3( value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8] ) ) )
1050  {
1051  mGetErrorResult = GL_INVALID_OPERATION;
1052  break;
1053  }
1054  }
1055  }
1056 
1057  inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1058  {
1059  for( int i = 0; i < count; ++i )
1060  {
1061  if( ! mProgramUniformsMat4.SetUniformValue(
1062  mCurrentProgram,
1063  location,
1064  Matrix( value ) ) )
1065  {
1066  mGetErrorResult = GL_INVALID_OPERATION;
1067  break;
1068  }
1069  }
1070  }
1071 
1072  inline void UseProgram(GLuint program)
1073  {
1074  mCurrentProgram = program;
1075  }
1076 
1077  inline void ValidateProgram(GLuint program)
1078  {
1079  }
1080 
1081  inline void VertexAttrib1f(GLuint indx, GLfloat x)
1082  {
1083  }
1084 
1085  inline void VertexAttrib1fv(GLuint indx, const GLfloat* values)
1086  {
1087  }
1088 
1089  inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1090  {
1091  }
1092 
1093  inline void VertexAttrib2fv(GLuint indx, const GLfloat* values)
1094  {
1095  }
1096 
1097  inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1098  {
1099  }
1100 
1101  inline void VertexAttrib3fv(GLuint indx, const GLfloat* values)
1102  {
1103  }
1104 
1105  inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1106  {
1107  }
1108 
1109  inline void VertexAttrib4fv(GLuint indx, const GLfloat* values)
1110  {
1111  }
1112 
1113  inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
1114  {
1115  }
1116 
1118  {
1119  }
1120 
1121  /* OpenGL ES 3.0 */
1122 
1123  inline void ReadBuffer(GLenum mode)
1124  {
1125  }
1126 
1127  inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
1128  {
1129  }
1130 
1131  inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
1132  {
1133  }
1134 
1135  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)
1136  {
1137  }
1138 
1139  inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1140  {
1141  }
1142 
1143  inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
1144  {
1145  }
1146 
1147  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)
1148  {
1149  }
1150 
1151  inline void GenQueries(GLsizei n, GLuint* ids)
1152  {
1153  }
1154 
1155  inline void DeleteQueries(GLsizei n, const GLuint* ids)
1156  {
1157  }
1158 
1159  inline GLboolean IsQuery(GLuint id)
1160  {
1161  return false;
1162  }
1163 
1164  inline void BeginQuery(GLenum target, GLuint id)
1165  {
1166  }
1167 
1168  inline void EndQuery(GLenum target)
1169  {
1170  }
1171 
1172  inline void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1173  {
1174  }
1175 
1176  inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1177  {
1178  }
1179 
1180  inline GLboolean UnmapBuffer(GLenum target)
1181  {
1182  return false;
1183  }
1184 
1185  inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1186  {
1187  }
1188 
1189  inline void DrawBuffers(GLsizei n, const GLenum* bufs)
1190  {
1191  }
1192 
1193  inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1194  {
1195  }
1196 
1197  inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1198  {
1199  }
1200 
1201  inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1202  {
1203  }
1204 
1205  inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1206  {
1207  }
1208 
1209  inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1210  {
1211  }
1212 
1213  inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1214  {
1215  }
1216 
1217  inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
1218  {
1219  }
1220 
1221  inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1222  {
1223  }
1224 
1225  inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1226  {
1227  }
1228 
1229  inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
1230  {
1231  return NULL;
1232  }
1233 
1234  inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
1235  {
1236  }
1237 
1238  inline void BindVertexArray(GLuint array)
1239  {
1240  }
1241 
1242  inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays)
1243  {
1244  }
1245 
1246  inline void GenVertexArrays(GLsizei n, GLuint* arrays)
1247  {
1248  }
1249 
1250  inline GLboolean IsVertexArray(GLuint array)
1251  {
1252  return false;
1253  }
1254 
1255  inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data)
1256  {
1257  }
1258 
1259  inline void BeginTransformFeedback(GLenum primitiveMode)
1260  {
1261  }
1262 
1263  inline void EndTransformFeedback(void)
1264  {
1265  }
1266 
1267  inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
1268  {
1269  }
1270 
1271  inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer)
1272  {
1273  }
1274 
1275  inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
1276  {
1277  }
1278 
1279  inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
1280  {
1281  }
1282 
1283  inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1284  {
1285  }
1286 
1287  inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
1288  {
1289  }
1290 
1291  inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
1292  {
1293  }
1294 
1295  inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1296  {
1297  }
1298 
1299  inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1300  {
1301  }
1302 
1303  inline void VertexAttribI4iv(GLuint index, const GLint* v)
1304  {
1305  }
1306 
1307  inline void VertexAttribI4uiv(GLuint index, const GLuint* v)
1308  {
1309  }
1310 
1311  inline void GetUniformuiv(GLuint program, GLint location, GLuint* params)
1312  {
1313  }
1314 
1315  inline GLint GetFragDataLocation(GLuint program, const GLchar *name)
1316  {
1317  return -1;
1318  }
1319 
1320  inline void Uniform1ui(GLint location, GLuint v0)
1321  {
1322  }
1323 
1324  inline void Uniform2ui(GLint location, GLuint v0, GLuint v1)
1325  {
1326  }
1327 
1328  inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1329  {
1330  }
1331 
1332  inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1333  {
1334  }
1335 
1336  inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value)
1337  {
1338  }
1339 
1340  inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value)
1341  {
1342  }
1343 
1344  inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value)
1345  {
1346  }
1347 
1348  inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value)
1349  {
1350  }
1351 
1352  inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
1353  {
1354  }
1355 
1356  inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
1357  {
1358  }
1359 
1360  inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
1361  {
1362  }
1363 
1364  inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1365  {
1366  }
1367 
1368  inline const GLubyte* GetStringi(GLenum name, GLuint index)
1369  {
1370  return NULL;
1371  }
1372 
1373  inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1374  {
1375  }
1376 
1377  inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
1378  {
1379  }
1380 
1381  inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
1382  {
1383  }
1384 
1385  inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
1386  {
1387  return GL_INVALID_INDEX;
1388  }
1389 
1390  inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
1391  {
1392  }
1393 
1394  inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
1395  {
1396  }
1397 
1398  inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1399  {
1400  }
1401 
1402  inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
1403  {
1404  }
1405 
1406  inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
1407  {
1408  }
1409 
1410  inline GLsync FenceSync(GLenum condition, GLbitfield flags)
1411  {
1412  return NULL;
1413  }
1414 
1415  inline GLboolean IsSync(GLsync sync)
1416  {
1417  return false;
1418  }
1419 
1420  inline void DeleteSync(GLsync sync)
1421  {
1422  }
1423 
1424  inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1425  {
1426  return 0;
1427  }
1428 
1429  inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1430  {
1431  }
1432 
1433  inline void GetInteger64v(GLenum pname, GLint64* params)
1434  {
1435  }
1436 
1437  inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
1438  {
1439  }
1440 
1441  inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
1442  {
1443  }
1444 
1445  inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
1446  {
1447  }
1448 
1449  inline void GenSamplers(GLsizei count, GLuint* samplers)
1450  {
1451  }
1452 
1453  inline void DeleteSamplers(GLsizei count, const GLuint* samplers)
1454  {
1455  }
1456 
1457  inline GLboolean IsSampler(GLuint sampler)
1458  {
1459  return false;
1460  }
1461 
1462  inline void BindSampler(GLuint unit, GLuint sampler)
1463  {
1464  }
1465 
1466  inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1467  {
1468  }
1469 
1470  inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
1471  {
1472  }
1473 
1474  inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1475  {
1476  }
1477 
1478  inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
1479  {
1480  }
1481 
1482  inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
1483  {
1484  }
1485 
1486  inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
1487  {
1488  }
1489 
1490  inline void VertexAttribDivisor(GLuint index, GLuint divisor)
1491  {
1492  }
1493 
1494  inline void BindTransformFeedback(GLenum target, GLuint id)
1495  {
1496  }
1497 
1498  inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
1499  {
1500  }
1501 
1502  inline void GenTransformFeedbacks(GLsizei n, GLuint* ids)
1503  {
1504  }
1505 
1506  inline GLboolean IsTransformFeedback(GLuint id)
1507  {
1508  return false;
1509  }
1510 
1511  inline void PauseTransformFeedback(void)
1512  {
1513  }
1514 
1515  inline void ResumeTransformFeedback(void)
1516  {
1517  }
1518 
1519  inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
1520  {
1521  mGetProgramBinaryCalled = true;
1522  }
1523 
1524  inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
1525  {
1526  }
1527 
1528  inline void ProgramParameteri(GLuint program, GLenum pname, GLint value)
1529  {
1530  }
1531 
1532  inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
1533  {
1534  }
1535 
1536  inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1537  {
1538  }
1539 
1540  inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1541  {
1542  }
1543 
1544  inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
1545  {
1546  }
1547 
1548  inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
1549  {
1550  }
1551 
1552 public: // TEST FUNCTIONS
1553  inline void SetCompileStatus( GLuint value ) { mCompileStatus = value; }
1554  inline void SetLinkStatus( GLuint value ) { mLinkStatus = value; }
1555  inline void SetGetAttribLocationResult( int result) { mGetAttribLocationResult = result; }
1556  inline void SetGetErrorResult( GLenum result) { mGetErrorResult = result; }
1557  inline void SetGetStringResult( GLubyte* result) { mGetStringResult = result; }
1558  inline void SetIsBufferResult( GLboolean result) { mIsBufferResult = result; }
1559  inline void SetIsEnabledResult( GLboolean result) { mIsEnabledResult = result; }
1560  inline void SetIsFramebufferResult( GLboolean result) { mIsFramebufferResult = result; }
1561  inline void SetIsProgramResult( GLboolean result) { mIsProgramResult = result; }
1562  inline void SetIsRenderbufferResult( GLboolean result) { mIsRenderbufferResult = result; }
1563  inline void SetIsShaderResult( GLboolean result) { mIsShaderResult = result; }
1564  inline void SetIsTextureResult( GLboolean result) { mIsTextureResult = result; }
1565  inline void SetCheckFramebufferStatusResult( GLenum result) { mCheckFramebufferStatusResult = result; }
1566  inline void SetNumBinaryFormats( GLint numFormats ) { mNumBinaryFormats = numFormats; }
1567  inline void SetBinaryFormats( GLint binaryFormats ) { mBinaryFormats = binaryFormats; }
1568  inline void SetProgramBinaryLength( GLint length ) { mProgramBinaryLength = length; }
1569 
1570  inline bool GetVertexAttribArrayState(GLuint index)
1571  {
1572  if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
1573  {
1574  // out of range
1575  return false;
1576  }
1577  return mVertexAttribArrayState[ index ];
1578  }
1579  inline void ClearVertexAttribArrayChanged() { mVertexAttribArrayChanged = false; }
1580  inline bool GetVertexAttribArrayChanged() { return mVertexAttribArrayChanged; }
1581 
1582  //Methods for CullFace verification
1583  inline void EnableCullFaceCallTrace(bool enable) { mCullFaceTrace.Enable(enable); }
1584  inline void ResetCullFaceCallStack() { mCullFaceTrace.Reset(); }
1585  inline TraceCallStack& GetCullFaceTrace() { return mCullFaceTrace; }
1586 
1587  //Methods for Enable/Disable call verification
1588  inline void EnableEnableDisableCallTrace(bool enable) { mEnableDisableTrace.Enable(enable); }
1589  inline void ResetEnableDisableCallStack() { mEnableDisableTrace.Reset(); }
1590  inline TraceCallStack& GetEnableDisableTrace() { return mEnableDisableTrace; }
1591 
1592  //Methods for Shader verification
1593  inline void EnableShaderCallTrace(bool enable) { mShaderTrace.Enable(enable); }
1594  inline void ResetShaderCallStack() { mShaderTrace.Reset(); }
1595  inline TraceCallStack& GetShaderTrace() { return mShaderTrace; }
1596 
1597  //Methods for Texture verification
1598  inline void EnableTextureCallTrace(bool enable) { mTextureTrace.Enable(enable); }
1599  inline void ResetTextureCallStack() { mTextureTrace.Reset(); }
1600  inline TraceCallStack& GetTextureTrace() { return mTextureTrace; }
1601 
1602  //Methods for Texture verification
1603  inline void EnableTexParameterCallTrace(bool enable) { mTexParamaterTrace.Enable(enable); }
1604  inline void ResetTexParameterCallStack() { mTexParamaterTrace.Reset(); }
1605  inline TraceCallStack& GetTexParameterTrace() { return mTexParamaterTrace; }
1606 
1607  //Methods for Draw verification
1608  inline void EnableDrawCallTrace(bool enable) { mDrawTrace.Enable(enable); }
1609  inline void ResetDrawCallStack() { mDrawTrace.Reset(); }
1610  inline TraceCallStack& GetDrawTrace() { return mDrawTrace; }
1611 
1612  template <typename T>
1613  inline bool GetUniformValue( const char* name, T& value ) const
1614  {
1615  for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
1616  program_it != mUniforms.end();
1617  ++program_it )
1618  {
1619  const UniformIDMap &uniformIDs = program_it->second;
1620 
1621  UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
1622  if( uniform_it != uniformIDs.end() )
1623  {
1624  // found one matching uniform name, lets check the value...
1625  GLuint programId = program_it->first;
1626  GLint uniformId = uniform_it->second;
1627 
1628  const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
1629  return mProgramUniforms.GetUniformValue( programId, uniformId, value );
1630  }
1631  }
1632  return false;
1633  }
1634 
1635 
1636  template <typename T>
1637  inline bool CheckUniformValue( const char* name, const T& value ) const
1638  {
1639  for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
1640  program_it != mUniforms.end();
1641  ++program_it )
1642  {
1643  const UniformIDMap &uniformIDs = program_it->second;
1644 
1645  UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
1646  if( uniform_it != uniformIDs.end() )
1647  {
1648  // found one matching uniform name, lets check the value...
1649  GLuint programId = program_it->first;
1650  GLint uniformId = uniform_it->second;
1651 
1652  const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
1653  if( mProgramUniforms.CheckUniformValue( programId, uniformId, value ) )
1654  {
1655  // the value matches
1656  return true;
1657  }
1658  }
1659  }
1660 
1661  fprintf(stderr, "Not found, printing possible values:\n" );
1662  for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
1663  program_it != mUniforms.end();
1664  ++program_it )
1665  {
1666  const UniformIDMap &uniformIDs = program_it->second;
1667 
1668  UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
1669  if( uniform_it != uniformIDs.end() )
1670  {
1671  // found one matching uniform name, lets check the value...
1672  GLuint programId = program_it->first;
1673  GLint uniformId = uniform_it->second;
1674 
1675  const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
1676  T origValue;
1677  if ( mProgramUniforms.GetUniformValue(programId, uniformId, origValue) )
1678  {
1679  std::stringstream out;
1680  out << uniform_it->first << ": " << origValue;
1681  fprintf(stderr, "%s\n", out.str().c_str() );
1682  }
1683  }
1684  }
1685  return false;
1686  }
1687 
1688  template <typename T>
1689  inline bool GetUniformValue( GLuint programId, GLuint uniformId, T& outValue) const
1690  {
1691  const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( outValue );
1692  return mProgramUniforms.GetUniformValue( programId, uniformId, outValue );
1693  }
1694 
1695  inline bool GetUniformIds( const char* name, GLuint& programId, GLuint& uniformId ) const
1696  {
1697  for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
1698  program_it != mUniforms.end();
1699  ++program_it )
1700  {
1701  const UniformIDMap &uniformIDs = program_it->second;
1702 
1703  UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
1704  if( uniform_it != uniformIDs.end() )
1705  {
1706  programId = program_it->first;
1707  uniformId = uniform_it->second;
1708  return true;
1709  }
1710  }
1711  return false;
1712  }
1713 
1714  inline GLuint GetLastShaderCompiled() const
1715  {
1716  return mLastShaderCompiled;
1717  }
1718 
1719  inline GLuint GetLastProgramCreated() const
1720  {
1721  return mLastProgramIdUsed;
1722  }
1723 
1724  inline GLbitfield GetLastClearMask() const
1725  {
1726  return mLastClearBitMask;
1727  }
1728 
1730  {
1739  };
1740 
1742  {
1747 
1748  ScissorParams() : x( 0 ), y( 0 ), width( 0 ), height( 0 ) { }
1749  };
1750 
1751  // Methods to check scissor tests
1752  inline const ScissorParams& GetScissorParams() const { return mScissorParams; }
1753 
1754  inline bool GetProgramBinaryCalled() const { return mGetProgramBinaryCalled; }
1755 
1756  inline unsigned int GetClearCountCalled() const { return mClearCount; }
1757 
1758  typedef std::vector<size_t> BufferDataCalls;
1759  inline const BufferDataCalls& GetBufferDataCalls() const { return mBufferDataCalls; }
1760  inline void ResetBufferDataCalls() { mBufferDataCalls.clear(); }
1761 
1762  typedef std::vector<size_t> BufferSubDataCalls;
1763  inline const BufferSubDataCalls& GetBufferSubDataCalls() const { return mBufferSubDataCalls; }
1764  inline void ResetBufferSubDataCalls() { mBufferSubDataCalls.clear(); }
1765 
1766 private:
1791  bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
1792  bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
1794  typedef std::map< GLuint, std::string> ShaderSourceMap;
1798  unsigned int mClearCount;
1799 
1807 
1808  // Data for manipulating the IDs returned by GenTextures
1810  std::vector<GLuint> mNextTextureIds;
1811  std::vector<GLuint> mDeletedTextureIds;
1812  std::vector<GLuint> mBoundTextures;
1813 
1815  {
1816  std::vector<GLuint> mBoundTextures;
1817  };
1818 
1819  ActiveTextureType mActiveTextures[ MIN_TEXTURE_UNIT_LIMIT ];
1820 
1827 
1828  // Shaders & Uniforms
1832  typedef std::map< std::string, GLint > UniformIDMap;
1833  typedef std::map< GLuint, UniformIDMap > ProgramUniformMap;
1835 
1836  template <typename T>
1837  struct ProgramUniformValue : public std::map< GLuint, std::map< GLint, T > >
1838  {
1839  public:
1840  typedef std::map< GLint, T > UniformValueMap;
1841  typedef std::map< GLuint, UniformValueMap > Map;
1842 
1843  bool SetUniformValue( GLuint program, GLuint uniform, const T& value )
1844  {
1845  if( program == 0 )
1846  {
1847  return false;
1848  }
1849 
1850  typename Map::iterator it = Map::find( program );
1851  if( it == Map::end() )
1852  {
1853  // if its the first uniform for this program add it
1854  std::pair< typename Map::iterator, bool > result =
1855  Map::insert( typename Map::value_type( program, UniformValueMap() ) );
1856  it = result.first;
1857  }
1858 
1859  UniformValueMap& uniforms = it->second;
1860  uniforms[uniform] = value;
1861 
1862  return true;
1863  }
1864 
1865  bool CheckUniformValue( GLuint program, GLuint uniform, const T& value ) const
1866  {
1867  T uniformValue;
1868  if ( GetUniformValue( program, uniform, uniformValue ) )
1869  {
1870  return value == uniformValue;
1871  }
1872 
1873  return false;
1874  }
1875 
1876  bool GetUniformValue( GLuint program, GLuint uniform, T& value ) const
1877  {
1878  if( program == 0 )
1879  {
1880  return false;
1881  }
1882 
1883  typename Map::const_iterator it = Map::find( program );
1884  if( it == Map::end() )
1885  {
1886  // Uniform values always initialised as 0
1887  value = GetZero();
1888  return true;
1889  }
1890 
1891  const UniformValueMap& uniforms = it->second;
1892  typename UniformValueMap::const_iterator it2 = uniforms.find( uniform );
1893  if( it2 == uniforms.end() )
1894  {
1895  // Uniform values always initialised as 0
1896  value = GetZero();
1897  return true;
1898  }
1899  value = it2->second;
1900 
1901  return true;
1902  }
1903 
1904  T GetZero() const;
1905  };
1913 
1914  inline const ProgramUniformValue<int>& GetProgramUniformsForType( const int ) const
1915  {
1916  return mProgramUniforms1i;
1917  }
1918  inline const ProgramUniformValue<float>& GetProgramUniformsForType( const float ) const
1919  {
1920  return mProgramUniforms1f;
1921  }
1922  inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType( const Vector2& ) const
1923  {
1924  return mProgramUniforms2f;
1925  }
1926  inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType( const Vector3& ) const
1927  {
1928  return mProgramUniforms3f;
1929  }
1930  inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType( const Vector4& ) const
1931  {
1932  return mProgramUniforms4f;
1933  }
1934  inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType( const Matrix& ) const
1935  {
1936  return mProgramUniformsMat4;
1937  }
1938  inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType( const Matrix3& ) const
1939  {
1940  return mProgramUniformsMat3;
1941  }
1942  inline void SetVertexAttribArray(GLuint index, bool state)
1943  {
1944  if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
1945  {
1946  // out of range
1947  return;
1948  }
1949  mVertexAttribArrayState[ index ] = state;
1950  mVertexAttribArrayChanged = true;
1951  }
1952 
1954 };
1955 
1956 template <>
1958 {
1959  return 0;
1960 }
1961 
1962 template <>
1964 {
1965  return 0.0f;
1966 }
1967 
1968 template <>
1970 {
1971  return Vector2::ZERO;
1972 }
1973 
1974 template <>
1976 {
1977  return Vector3::ZERO;
1978 }
1979 
1980 template <>
1982 {
1983  return Vector4::ZERO;
1984 }
1985 
1986 template <>
1988 {
1989  return Matrix();
1990 }
1991 
1992 template <>
1994 {
1995  return Matrix3( Matrix() );
1996 }
1997 
1998 } // namespace Dali
1999 
2000 bool BlendEnabled(const Dali::TraceCallStack& callStack);
2001 bool BlendDisabled(const Dali::TraceCallStack& callStack);
2002 
2003 
2004 
2005 
2006 #endif // __TEST_GL_ES_H__
Dali Docs Home
Read more about Dali