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