Dali 3D User Interface Engine
gl-implementation.h
Go to the documentation of this file.
1 #ifndef __DALI_INTERNAL_GL_IMPLEMENTATION_H__
2 #define __DALI_INTERNAL_GL_IMPLEMENTATION_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 #ifndef DALI_GLES_VERSION
23 #error "OpenGL ES version not specified"
24 #endif
25 
26 #if DALI_GLES_VERSION >= 31
27 #include <GLES3/gl31.h>
28 #elif DALI_GLES_VERSION >= 30
29 #include <GLES3/gl3.h>
30 #else
31 #include <cstdlib>
32 #include <GLES2/gl2.h>
33 #endif
34 
36 
37 // INTERNAL INCLUDES
38 #include <gl/gl-extensions.h>
39 
40 namespace Dali
41 {
42 
43 namespace Internal
44 {
45 
46 namespace Adaptor
47 {
48 
55 {
56 
57 public:
58  virtual ~GlImplementation() {}
59 
60  void PreRender()
61  {
62  /* Do nothing in main implementation */
63  }
64 
65  void PostRender()
66  {
67  /* Do nothing in main implementation */
68  }
69 
70  /* OpenGL ES 2.0 */
71 
72  void ActiveTexture (GLenum texture)
73  {
74  glActiveTexture(texture);
75  }
76 
77  void AttachShader (GLuint program, GLuint shader)
78  {
79  glAttachShader(program,shader);
80  }
81 
82  void BindAttribLocation (GLuint program, GLuint index, const char* name)
83  {
84  glBindAttribLocation(program,index,name);
85  }
86 
87  void BindBuffer (GLenum target, GLuint buffer)
88  {
89  glBindBuffer(target,buffer);
90  }
91 
92  void BindFramebuffer (GLenum target, GLuint framebuffer)
93  {
94  glBindFramebuffer(target,framebuffer);
95  }
96 
97  void BindRenderbuffer (GLenum target, GLuint renderbuffer)
98  {
99  glBindRenderbuffer(target,renderbuffer);
100  }
101 
102  void BindTexture (GLenum target, GLuint texture)
103  {
104  glBindTexture(target,texture);
105  }
106 
107  void BlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
108  {
109  glBlendColor(red,green,blue,alpha);
110  }
111 
112  void BlendEquation ( GLenum mode )
113  {
114  glBlendEquation(mode);
115  }
116 
117  void BlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
118  {
119  glBlendEquationSeparate(modeRGB,modeAlpha);
120  }
121 
122  void BlendFunc (GLenum sfactor, GLenum dfactor)
123  {
124  glBlendFunc(sfactor,dfactor);
125  }
126 
127  void BlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
128  {
129  glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
130  }
131 
132  void BufferData (GLenum target, GLsizeiptr size, const void* data, GLenum usage)
133  {
134  glBufferData(target,size,data,usage);
135  }
136 
137  void BufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
138  {
139  glBufferSubData(target,offset,size,data);
140  }
141 
143  {
144  return glCheckFramebufferStatus(target);
145  }
146 
147  void Clear (GLbitfield mask)
148  {
149  glClear(mask);
150  }
151 
152  void ClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
153  {
154  glClearColor(red,green,blue,alpha);
155  }
156 
157  void ClearDepthf (GLclampf depth)
158  {
159  glClearDepthf(depth);
160  }
161 
163  {
164  glClearStencil(s);
165  }
166 
167  void ColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
168  {
169  glColorMask(red,green,blue,alpha);
170  }
171 
172  void CompileShader (GLuint shader)
173  {
174  glCompileShader(shader);
175  }
176 
177  void CompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
178  {
179  glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data);
180  }
181 
182  void CompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
183  {
184  glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data);
185  }
186 
187  void CopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
188  {
189  glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
190  }
191 
192  void CopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
193  {
194  glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
195  }
196 
198  {
199  return glCreateProgram();
200  }
201 
203  {
204  return glCreateShader(type);
205  }
206 
207  void CullFace (GLenum mode)
208  {
209  glCullFace(mode);
210  }
211 
212  void DeleteBuffers (GLsizei n, const GLuint* buffers)
213  {
214  glDeleteBuffers(n,buffers);
215  }
216 
217  void DeleteFramebuffers (GLsizei n, const GLuint* framebuffers)
218  {
219  glDeleteFramebuffers(n,framebuffers);
220  }
221 
222  void DeleteProgram (GLuint program)
223  {
224  glDeleteProgram(program);
225  }
226 
227  void DeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers)
228  {
229  glDeleteRenderbuffers(n,renderbuffers);
230  }
231 
232  void DeleteShader (GLuint shader)
233  {
234  glDeleteShader(shader);
235  }
236 
237  void DeleteTextures (GLsizei n, const GLuint* textures)
238  {
239  glDeleteTextures(n,textures);
240  }
241 
242  void DepthFunc (GLenum func)
243  {
244  glDepthFunc(func);
245  }
246 
247  void DepthMask (GLboolean flag)
248  {
249  glDepthMask(flag);
250  }
251 
252  void DepthRangef (GLclampf zNear, GLclampf zFar)
253  {
254  glDepthRangef(zNear,zFar);
255  }
256 
257  void DetachShader (GLuint program, GLuint shader)
258  {
259  glDetachShader(program,shader);
260  }
261 
262  void Disable (GLenum cap)
263  {
264  glDisable(cap);
265  }
266 
268  {
269  glDisableVertexAttribArray(index);
270  }
271 
272  void DrawArrays (GLenum mode, GLint first, GLsizei count)
273  {
274  glDrawArrays(mode,first,count);
275  }
276 
277  void DrawElements (GLenum mode, GLsizei count, GLenum type, const void* indices)
278  {
279  glDrawElements(mode,count,type,indices);
280  }
281 
282  void Enable (GLenum cap)
283  {
284  glEnable(cap);
285  }
286 
288  {
289  glEnableVertexAttribArray(index);
290  }
291 
292  void Finish (void)
293  {
294  glFinish();
295  }
296 
297  void Flush (void)
298  {
299  glFlush();
300  }
301 
302  void FramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
303  {
304  glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer);
305  }
306 
307  void FramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
308  {
309  glFramebufferTexture2D(target,attachment,textarget,texture,level);
310  }
311 
312  void FrontFace (GLenum mode)
313  {
314  glFrontFace(mode);
315  }
316 
317  void GenBuffers (GLsizei n, GLuint* buffers)
318  {
319  glGenBuffers(n,buffers);
320  }
321 
322  void GenerateMipmap (GLenum target)
323  {
324  glGenerateMipmap(target);
325  }
326 
327  void GenFramebuffers (GLsizei n, GLuint* framebuffers)
328  {
329  glGenFramebuffers(n,framebuffers);
330  }
331 
332  void GenRenderbuffers (GLsizei n, GLuint* renderbuffers)
333  {
334  glGenRenderbuffers(n,renderbuffers);
335  }
336 
337  void GenTextures (GLsizei n, GLuint* textures)
338  {
339  glGenTextures(n,textures);
340  }
341 
342  void GetActiveAttrib (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
343  {
344  glGetActiveAttrib(program,index,bufsize,length,size,type,name);
345  }
346 
347  void GetActiveUniform (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
348  {
349  glGetActiveUniform(program,index,bufsize,length,size,type,name);
350  }
351 
352  void GetAttachedShaders (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
353  {
354  glGetAttachedShaders(program,maxcount,count,shaders);
355  }
356 
357  int GetAttribLocation (GLuint program, const char* name)
358  {
359  return glGetAttribLocation(program,name);
360  }
361 
362  void GetBooleanv (GLenum pname, GLboolean* params)
363  {
364  glGetBooleanv(pname,params);
365  }
366 
367  void GetBufferParameteriv (GLenum target, GLenum pname, GLint* params)
368  {
369  glGetBufferParameteriv(target,pname,params);
370  }
371 
373  {
374  return glGetError();
375  }
376 
377  void GetFloatv (GLenum pname, GLfloat* params)
378  {
379  glGetFloatv(pname,params);
380  }
381 
382  void GetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params)
383  {
384  glGetFramebufferAttachmentParameteriv(target,attachment,pname,params);
385  }
386 
387  void GetIntegerv (GLenum pname, GLint* params)
388  {
389  glGetIntegerv(pname,params);
390  }
391 
392  void GetProgramiv (GLuint program, GLenum pname, GLint* params)
393  {
394  glGetProgramiv(program,pname,params);
395  }
396 
397  void GetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
398  {
399  glGetProgramInfoLog(program,bufsize,length,infolog);
400  }
401 
402  void GetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params)
403  {
404  glGetRenderbufferParameteriv(target,pname,params);
405  }
406 
407  void GetShaderiv (GLuint shader, GLenum pname, GLint* params)
408  {
409  glGetShaderiv(shader,pname,params);
410  }
411 
412  void GetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
413  {
414  glGetShaderInfoLog(shader,bufsize,length,infolog);
415  }
416 
417  void GetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
418  {
419  glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision);
420  }
421 
422  void GetShaderSource (GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
423  {
424  glGetShaderSource(shader,bufsize,length,source);
425  }
426 
427  const GLubyte* GetString (GLenum name)
428  {
429  return glGetString(name);
430  }
431 
432  void GetTexParameterfv (GLenum target, GLenum pname, GLfloat* params)
433  {
434  glGetTexParameterfv(target,pname,params);
435  }
436 
437  void GetTexParameteriv (GLenum target, GLenum pname, GLint* params)
438  {
439  glGetTexParameteriv(target,pname,params);
440  }
441 
442  void GetUniformfv (GLuint program, GLint location, GLfloat* params)
443  {
444  glGetUniformfv(program,location,params);
445  }
446 
447  void GetUniformiv (GLuint program, GLint location, GLint* params)
448  {
449  glGetUniformiv(program,location,params);
450  }
451 
452  int GetUniformLocation (GLuint program, const char* name)
453  {
454  return glGetUniformLocation(program,name);
455  }
456 
457  void GetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params)
458  {
459  glGetVertexAttribfv(index,pname,params);
460  }
461 
462  void GetVertexAttribiv (GLuint index, GLenum pname, GLint* params)
463  {
464  glGetVertexAttribiv(index,pname,params);
465  }
466 
467  void GetVertexAttribPointerv (GLuint index, GLenum pname, void** pointer)
468  {
469  glGetVertexAttribPointerv(index,pname,pointer);
470  }
471 
472  void Hint (GLenum target, GLenum mode)
473  {
474  glHint(target,mode);
475  }
476 
478  {
479  return glIsBuffer(buffer);
480  }
481 
483  {
484  return glIsEnabled(cap);
485  }
486 
488  {
489  return glIsFramebuffer(framebuffer);
490  }
491 
493  {
494  return glIsProgram(program);
495  }
496 
498  {
499  return glIsRenderbuffer(renderbuffer);
500  }
501 
503  {
504  return glIsShader(shader);
505  }
506 
508  {
509  return glIsTexture(texture);
510  }
511 
513  {
514  glLineWidth(width);
515  }
516 
517  void LinkProgram (GLuint program)
518  {
519  glLinkProgram(program);
520  }
521 
522  void PixelStorei (GLenum pname, GLint param)
523  {
524  glPixelStorei(pname,param);
525  }
526 
527  void PolygonOffset (GLfloat factor, GLfloat units)
528  {
529  glPolygonOffset(factor,units);
530  }
531 
532  void ReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
533  {
534  glReadPixels(x,y,width,height,format,type,pixels);
535  }
536 
538  {
539  glReleaseShaderCompiler();
540  }
541 
542  void RenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
543  {
544  glRenderbufferStorage(target,internalformat,width,height);
545  }
546 
547  void SampleCoverage (GLclampf value, GLboolean invert)
548  {
549  glSampleCoverage(value,invert);
550  }
551 
553  {
554  glScissor(x,y,width,height);
555  }
556 
557  void ShaderBinary (GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
558  {
559  glShaderBinary(n,shaders,binaryformat,binary,length);
560  }
561 
562  void ShaderSource (GLuint shader, GLsizei count, const char** string, const GLint* length)
563  {
564  glShaderSource(shader,count,string,length);
565  }
566 
567  void StencilFunc (GLenum func, GLint ref, GLuint mask)
568  {
569  glStencilFunc(func,ref,mask);
570  }
571 
572  void StencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
573  {
574  glStencilFuncSeparate(face,func,ref,mask);
575  }
576 
577  void StencilMask (GLuint mask)
578  {
579  glStencilMask(mask);
580  }
581 
583  {
584  glStencilMaskSeparate(face,mask);
585  }
586 
587  void StencilOp (GLenum fail, GLenum zfail, GLenum zpass)
588  {
589  glStencilOp(fail,zfail,zpass);
590  }
591 
592  void StencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
593  {
594  glStencilOpSeparate(face,fail,zfail,zpass);
595  }
596 
597  void TexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
598  {
599  glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels);
600  }
601 
602  void TexParameterf (GLenum target, GLenum pname, GLfloat param)
603  {
604  glTexParameterf(target,pname,param);
605  }
606 
607  void TexParameterfv (GLenum target, GLenum pname, const GLfloat* params)
608  {
609  glTexParameterfv(target,pname,params);
610  }
611 
612  void TexParameteri (GLenum target, GLenum pname, GLint param)
613  {
614  glTexParameteri(target,pname,param);
615  }
616 
617  void TexParameteriv (GLenum target, GLenum pname, const GLint* params)
618  {
619  glTexParameteriv(target,pname,params);
620  }
621 
622  void TexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
623  {
624  glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
625  }
626 
627  void Uniform1f (GLint location, GLfloat x)
628  {
629  glUniform1f(location,x);
630  }
631 
632  void Uniform1fv (GLint location, GLsizei count, const GLfloat* v)
633  {
634  glUniform1fv(location,count,v);
635  }
636 
637  void Uniform1i (GLint location, GLint x)
638  {
639  glUniform1i(location,x);
640  }
641 
642  void Uniform1iv (GLint location, GLsizei count, const GLint* v)
643  {
644  glUniform1iv(location,count,v);
645  }
646 
647  void Uniform2f (GLint location, GLfloat x, GLfloat y)
648  {
649  glUniform2f(location,x,y);
650  }
651 
652  void Uniform2fv (GLint location, GLsizei count, const GLfloat* v)
653  {
654  glUniform2fv(location,count,v);
655  }
656 
657  void Uniform2i (GLint location, GLint x, GLint y)
658  {
659  glUniform2i(location,x,y);
660  }
661 
662  void Uniform2iv (GLint location, GLsizei count, const GLint* v)
663  {
664  glUniform2iv(location,count,v);
665  }
666 
667  void Uniform3f (GLint location, GLfloat x, GLfloat y, GLfloat z)
668  {
669  glUniform3f(location,x,y,z);
670  }
671 
672  void Uniform3fv (GLint location, GLsizei count, const GLfloat* v)
673  {
674  glUniform3fv(location,count,v);
675  }
676 
677  void Uniform3i (GLint location, GLint x, GLint y, GLint z)
678  {
679  glUniform3i(location,x,y,z);
680  }
681 
682  void Uniform3iv (GLint location, GLsizei count, const GLint* v)
683  {
684  glUniform3iv(location,count,v);
685  }
686 
687  void Uniform4f (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
688  {
689  glUniform4f(location,x,y,z,w);
690  }
691 
692  void Uniform4fv (GLint location, GLsizei count, const GLfloat* v)
693  {
694  glUniform4fv(location,count,v);
695  }
696 
697  void Uniform4i (GLint location, GLint x, GLint y, GLint z, GLint w)
698  {
699  glUniform4i(location,x,y,z,w);
700  }
701 
702  void Uniform4iv (GLint location, GLsizei count, const GLint* v)
703  {
704  glUniform4iv(location,count,v);
705  }
706 
707  void UniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
708  {
709  glUniformMatrix2fv(location,count,transpose,value);
710  }
711 
712  void UniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
713  {
714  glUniformMatrix3fv(location,count,transpose,value);
715  }
716 
717  void UniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
718  {
719  glUniformMatrix4fv(location,count,transpose,value);
720  }
721 
722  void UseProgram (GLuint program)
723  {
724  glUseProgram(program);
725  }
726 
727  void ValidateProgram (GLuint program)
728  {
729  glValidateProgram(program);
730  }
731 
733  {
734  glVertexAttrib1f(indx,x);
735  }
736 
737  void VertexAttrib1fv (GLuint indx, const GLfloat* values)
738  {
739  glVertexAttrib1fv(indx,values);
740  }
741 
743  {
744  glVertexAttrib2f(indx,x,y);
745  }
746 
747  void VertexAttrib2fv (GLuint indx, const GLfloat* values)
748  {
749  glVertexAttrib2fv(indx,values);
750  }
751 
753  {
754  glVertexAttrib3f(indx,x,y,z);
755  }
756 
757  void VertexAttrib3fv (GLuint indx, const GLfloat* values)
758  {
759  glVertexAttrib3fv(indx,values);
760  }
761 
763  {
764  glVertexAttrib4f(indx,x,y,z,w);
765  }
766 
767  void VertexAttrib4fv (GLuint indx, const GLfloat* values)
768  {
769  glVertexAttrib4fv(indx,values);
770  }
771 
772  void VertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
773  {
774  glVertexAttribPointer(indx,size,type,normalized,stride,ptr);
775  }
776 
778  {
779  glViewport(x,y,width,height);
780  }
781 
782  /* OpenGL ES 3.0 */
783 
784  void ReadBuffer(GLenum mode)
785  {
786 #if DALI_GLES_VERSION >= 30
787  glReadBuffer(mode);
788 #endif // DALI_GLES_VERSION >= 30
789  }
790 
791  void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
792  {
793 #if DALI_GLES_VERSION >= 30
794  glDrawRangeElements(mode,start,end,count,type,indices);
795 #endif // DALI_GLES_VERSION >= 30
796  }
797 
798  void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
799  {
800 #if DALI_GLES_VERSION >= 30
801  glTexImage3D(target,level,internalformat,width,height,depth,border,format,type,pixels);
802 #endif // DALI_GLES_VERSION >= 30
803  }
804 
805  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)
806  {
807 #if DALI_GLES_VERSION >= 30
808  glTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
809 #endif // DALI_GLES_VERSION >= 30
810  }
811 
812  void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
813  {
814 #if DALI_GLES_VERSION >= 30
815  glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
816 #endif // DALI_GLES_VERSION >= 30
817  }
818 
819  void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
820  {
821 #if DALI_GLES_VERSION >= 30
822  glCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imageSize,data);
823 #endif // DALI_GLES_VERSION >= 30
824  }
825 
826  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)
827  {
828 #if DALI_GLES_VERSION >= 30
829  glCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data);
830 #endif // DALI_GLES_VERSION >= 30
831  }
832 
833  void GenQueries(GLsizei n, GLuint* ids)
834  {
835 #if DALI_GLES_VERSION >= 30
836  glGenQueries(n,ids);
837 #endif // DALI_GLES_VERSION >= 30
838  }
839 
840  void DeleteQueries(GLsizei n, const GLuint* ids)
841  {
842 #if DALI_GLES_VERSION >= 30
843  glDeleteQueries(n,ids);
844 #endif // DALI_GLES_VERSION >= 30
845  }
846 
848  {
849 #if DALI_GLES_VERSION >= 30
850  return glIsQuery(id);
851 #else
852  return 0;
853 #endif // DALI_GLES_VERSION >= 30
854  }
855 
856  void BeginQuery(GLenum target, GLuint id)
857  {
858 #if DALI_GLES_VERSION >= 30
859  glBeginQuery(target,id);
860 #endif // DALI_GLES_VERSION >= 30
861  }
862 
863  void EndQuery(GLenum target)
864  {
865 #if DALI_GLES_VERSION >= 30
866  glEndQuery(target);
867 #endif // DALI_GLES_VERSION >= 30
868  }
869 
870  void GetQueryiv(GLenum target, GLenum pname, GLint* params)
871  {
872 #if DALI_GLES_VERSION >= 30
873  glGetQueryiv(target,pname,params);
874 #endif // DALI_GLES_VERSION >= 30
875  }
876 
877  void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
878  {
879 #if DALI_GLES_VERSION >= 30
880  glGetQueryObjectuiv(id,pname,params);
881 #endif // DALI_GLES_VERSION >= 30
882  }
883 
885  {
886 #if DALI_GLES_VERSION >= 30
887  return glUnmapBuffer(target);
888 #else
889  return 0;
890 #endif // DALI_GLES_VERSION >= 30
891  }
892 
893  void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
894  {
895 #if DALI_GLES_VERSION >= 30
896  glGetBufferPointerv(target,pname,params);
897 #endif // DALI_GLES_VERSION >= 30
898  }
899 
900  void DrawBuffers(GLsizei n, const GLenum* bufs)
901  {
902 #if DALI_GLES_VERSION >= 30
903  glDrawBuffers(n,bufs);
904 #endif // DALI_GLES_VERSION >= 30
905  }
906 
907  void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
908  {
909 #if DALI_GLES_VERSION >= 30
910  glUniformMatrix2x3fv(location,count,transpose,value);
911 #endif // DALI_GLES_VERSION >= 30
912  }
913 
914  void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
915  {
916 #if DALI_GLES_VERSION >= 30
917  glUniformMatrix3x2fv(location,count,transpose,value);
918 #endif // DALI_GLES_VERSION >= 30
919  }
920 
921  void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
922  {
923 #if DALI_GLES_VERSION >= 30
924  glUniformMatrix2x4fv(location,count,transpose,value);
925 #endif // DALI_GLES_VERSION >= 30
926  }
927 
928  void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
929  {
930 #if DALI_GLES_VERSION >= 30
931  glUniformMatrix4x2fv(location,count,transpose,value);
932 #endif // DALI_GLES_VERSION >= 30
933  }
934 
935  void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
936  {
937 #if DALI_GLES_VERSION >= 30
938  glUniformMatrix3x4fv(location,count,transpose,value);
939 #endif // DALI_GLES_VERSION >= 30
940  }
941 
942  void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
943  {
944 #if DALI_GLES_VERSION >= 30
945  glUniformMatrix4x3fv(location,count,transpose,value);
946 #endif // DALI_GLES_VERSION >= 30
947  }
948 
949  void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
950  {
951 #if DALI_GLES_VERSION >= 30
952  glBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
953 #endif // DALI_GLES_VERSION >= 30
954  }
955 
957  {
958 #if DALI_GLES_VERSION >= 30
959  glRenderbufferStorageMultisample(target,samples,internalformat,width,height);
960 #endif // DALI_GLES_VERSION >= 30
961  }
962 
963  void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
964  {
965 #if DALI_GLES_VERSION >= 30
966  glFramebufferTextureLayer(target,attachment,texture,level,layer);
967 #endif // DALI_GLES_VERSION >= 30
968  }
969 
971  {
972 #if DALI_GLES_VERSION >= 30
973  return glMapBufferRange(target,offset,length,access);
974 #else
975  return NULL;
976 #endif // DALI_GLES_VERSION >= 30
977  }
978 
980  {
981 #if DALI_GLES_VERSION >= 30
982  glFlushMappedBufferRange(target,offset,length);
983 #endif // DALI_GLES_VERSION >= 30
984  }
985 
987  {
988 #if DALI_GLES_VERSION >= 30
989  glBindVertexArray(array);
990 #endif // DALI_GLES_VERSION >= 30
991  }
992 
993  void DeleteVertexArrays(GLsizei n, const GLuint* arrays)
994  {
995 #if DALI_GLES_VERSION >= 30
996  glDeleteVertexArrays(n,arrays);
997 #endif // DALI_GLES_VERSION >= 30
998  }
999 
1000  void GenVertexArrays(GLsizei n, GLuint* arrays)
1001  {
1002 #if DALI_GLES_VERSION >= 30
1003  glGenVertexArrays(n,arrays);
1004 #endif // DALI_GLES_VERSION >= 30
1005  }
1006 
1008  {
1009 #if DALI_GLES_VERSION >= 30
1010  return glIsVertexArray(array);
1011 #else
1012  return 0;
1013 #endif // DALI_GLES_VERSION >= 30
1014  }
1015 
1016  void GetIntegeri_v(GLenum target, GLuint index, GLint* data)
1017  {
1018 #if DALI_GLES_VERSION >= 30
1019  glGetIntegeri_v(target,index,data);
1020 #endif // DALI_GLES_VERSION >= 30
1021  }
1022 
1023  void BeginTransformFeedback(GLenum primitiveMode)
1024  {
1025 #if DALI_GLES_VERSION >= 30
1026  glBeginTransformFeedback(primitiveMode);
1027 #endif // DALI_GLES_VERSION >= 30
1028  }
1029 
1031  {
1032 #if DALI_GLES_VERSION >= 30
1033  glEndTransformFeedback();
1034 #endif // DALI_GLES_VERSION >= 30
1035  }
1036 
1037  void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
1038  {
1039 #if DALI_GLES_VERSION >= 30
1040  glBindBufferRange(target,index,buffer,offset,size);
1041 #endif // DALI_GLES_VERSION >= 30
1042  }
1043 
1044  void BindBufferBase(GLenum target, GLuint index, GLuint buffer)
1045  {
1046 #if DALI_GLES_VERSION >= 30
1047  glBindBufferBase(target,index,buffer);
1048 #endif // DALI_GLES_VERSION >= 30
1049  }
1050 
1051  void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
1052  {
1053 #if DALI_GLES_VERSION >= 30
1054  glTransformFeedbackVaryings(program,count,varyings,bufferMode);
1055 #endif // DALI_GLES_VERSION >= 30
1056  }
1057 
1058  void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
1059  {
1060 #if DALI_GLES_VERSION >= 30
1061  glGetTransformFeedbackVarying(program,index,bufSize,length,size,type,name);
1062 #endif // DALI_GLES_VERSION >= 30
1063  }
1064 
1065  void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1066  {
1067 #if DALI_GLES_VERSION >= 30
1068  glVertexAttribIPointer(index,size,type,stride,pointer);
1069 #endif // DALI_GLES_VERSION >= 30
1070  }
1071 
1072  void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
1073  {
1074 #if DALI_GLES_VERSION >= 30
1075  glGetVertexAttribIiv(index,pname,params);
1076 #endif // DALI_GLES_VERSION >= 30
1077  }
1078 
1079  void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
1080  {
1081 #if DALI_GLES_VERSION >= 30
1082  glGetVertexAttribIuiv(index,pname,params);
1083 #endif // DALI_GLES_VERSION >= 30
1084  }
1085 
1086  void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1087  {
1088 #if DALI_GLES_VERSION >= 30
1089  glVertexAttribI4i(index,x,y,z,w);
1090 #endif // DALI_GLES_VERSION >= 30
1091  }
1092 
1094  {
1095 #if DALI_GLES_VERSION >= 30
1096  glVertexAttribI4ui(index,x,y,z,w);
1097 #endif // DALI_GLES_VERSION >= 30
1098  }
1099 
1100  void VertexAttribI4iv(GLuint index, const GLint* v)
1101  {
1102 #if DALI_GLES_VERSION >= 30
1103  glVertexAttribI4iv(index,v);
1104 #endif // DALI_GLES_VERSION >= 30
1105  }
1106 
1107  void VertexAttribI4uiv(GLuint index, const GLuint* v)
1108  {
1109 #if DALI_GLES_VERSION >= 30
1110  glVertexAttribI4uiv(index,v);
1111 #endif // DALI_GLES_VERSION >= 30
1112  }
1113 
1114  void GetUniformuiv(GLuint program, GLint location, GLuint* params)
1115  {
1116 #if DALI_GLES_VERSION >= 30
1117  glGetUniformuiv(program,location,params);
1118 #endif // DALI_GLES_VERSION >= 30
1119  }
1120 
1121  GLint GetFragDataLocation(GLuint program, const GLchar *name)
1122  {
1123 #if DALI_GLES_VERSION >= 30
1124  return glGetFragDataLocation(program,name);
1125 #else
1126  return -1;
1127 #endif // DALI_GLES_VERSION >= 30
1128  }
1129 
1130  void Uniform1ui(GLint location, GLuint v0)
1131  {
1132 #if DALI_GLES_VERSION >= 30
1133  glUniform1ui(location,v0);
1134 #endif // DALI_GLES_VERSION >= 30
1135  }
1136 
1137  void Uniform2ui(GLint location, GLuint v0, GLuint v1)
1138  {
1139 #if DALI_GLES_VERSION >= 30
1140  glUniform2ui(location,v0,v1);
1141 #endif // DALI_GLES_VERSION >= 30
1142  }
1143 
1144  void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1145  {
1146 #if DALI_GLES_VERSION >= 30
1147  glUniform3ui(location,v0,v1,v2);
1148 #endif // DALI_GLES_VERSION >= 30
1149  }
1150 
1151  void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1152  {
1153 #if DALI_GLES_VERSION >= 30
1154  glUniform4ui(location,v0,v1,v2,v3);
1155 #endif // DALI_GLES_VERSION >= 30
1156  }
1157 
1158  void Uniform1uiv(GLint location, GLsizei count, const GLuint* value)
1159  {
1160 #if DALI_GLES_VERSION >= 30
1161  glUniform1uiv(location,count,value);
1162 #endif // DALI_GLES_VERSION >= 30
1163  }
1164 
1165  void Uniform2uiv(GLint location, GLsizei count, const GLuint* value)
1166  {
1167 #if DALI_GLES_VERSION >= 30
1168  glUniform2uiv(location,count,value);
1169 #endif // DALI_GLES_VERSION >= 30
1170  }
1171 
1172  void Uniform3uiv(GLint location, GLsizei count, const GLuint* value)
1173  {
1174 #if DALI_GLES_VERSION >= 30
1175  glUniform3uiv(location,count,value);
1176 #endif // DALI_GLES_VERSION >= 30
1177  }
1178 
1179  void Uniform4uiv(GLint location, GLsizei count, const GLuint* value)
1180  {
1181 #if DALI_GLES_VERSION >= 30
1182  glUniform4uiv(location,count,value);
1183 #endif // DALI_GLES_VERSION >= 30
1184  }
1185 
1186  void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
1187  {
1188 #if DALI_GLES_VERSION >= 30
1189  glClearBufferiv(buffer,drawbuffer,value);
1190 #endif // DALI_GLES_VERSION >= 30
1191  }
1192 
1193  void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
1194  {
1195 #if DALI_GLES_VERSION >= 30
1196  glClearBufferuiv(buffer,drawbuffer,value);
1197 #endif // DALI_GLES_VERSION >= 30
1198  }
1199 
1200  void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
1201  {
1202 #if DALI_GLES_VERSION >= 30
1203  glClearBufferfv(buffer,drawbuffer,value);
1204 #endif // DALI_GLES_VERSION >= 30
1205  }
1206 
1207  void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1208  {
1209 #if DALI_GLES_VERSION >= 30
1210  glClearBufferfi(buffer,drawbuffer,depth,stencil);
1211 #endif // DALI_GLES_VERSION >= 30
1212  }
1213 
1214  const GLubyte* GetStringi(GLenum name, GLuint index)
1215  {
1216 #if DALI_GLES_VERSION >= 30
1217  return glGetStringi(name,index);
1218 #else
1219  return NULL;
1220 #endif // DALI_GLES_VERSION >= 30
1221  }
1222 
1223  void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1224  {
1225 #if DALI_GLES_VERSION >= 30
1226  glCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size);
1227 #endif // DALI_GLES_VERSION >= 30
1228  }
1229 
1230  void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
1231  {
1232 #if DALI_GLES_VERSION >= 30
1233  glGetUniformIndices(program,uniformCount,uniformNames,uniformIndices);
1234 #endif // DALI_GLES_VERSION >= 30
1235  }
1236 
1237  void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
1238  {
1239 #if DALI_GLES_VERSION >= 30
1240  glGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params);
1241 #endif // DALI_GLES_VERSION >= 30
1242  }
1243 
1244  GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
1245  {
1246 #if DALI_GLES_VERSION >= 30
1247  return glGetUniformBlockIndex(program,uniformBlockName);
1248 #else
1249  return 0;
1250 #endif // DALI_GLES_VERSION >= 30
1251  }
1252 
1253  void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
1254  {
1255 #if DALI_GLES_VERSION >= 30
1256  glGetActiveUniformBlockiv(program,uniformBlockIndex,pname,params);
1257 #endif // DALI_GLES_VERSION >= 30
1258  }
1259 
1260  void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
1261  {
1262 #if DALI_GLES_VERSION >= 30
1263  glGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,length,uniformBlockName);
1264 #endif // DALI_GLES_VERSION >= 30
1265  }
1266 
1267  void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1268  {
1269 #if DALI_GLES_VERSION >= 30
1270  glUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding);
1271 #endif // DALI_GLES_VERSION >= 30
1272  }
1273 
1274  void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
1275  {
1276 #if DALI_GLES_VERSION >= 30
1277  glDrawArraysInstanced(mode,first,count,instanceCount);
1278 #endif // DALI_GLES_VERSION >= 30
1279  }
1280 
1281  void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
1282  {
1283 #if DALI_GLES_VERSION >= 30
1284  glDrawElementsInstanced(mode,count,type,indices,instanceCount);
1285 #endif // DALI_GLES_VERSION >= 30
1286  }
1287 
1288  GLsync FenceSync(GLenum condition, GLbitfield flags)
1289  {
1290 #if DALI_GLES_VERSION >= 30
1291  return glFenceSync(condition,flags);
1292 #else
1293  return NULL;
1294 #endif // DALI_GLES_VERSION >= 30
1295  }
1296 
1298  {
1299 #if DALI_GLES_VERSION >= 30
1300  return glIsSync(sync);
1301 #else
1302  return 0;
1303 #endif // DALI_GLES_VERSION >= 30
1304  }
1305 
1306  void DeleteSync(GLsync sync)
1307  {
1308 #if DALI_GLES_VERSION >= 30
1309  glDeleteSync(sync);
1310 #endif // DALI_GLES_VERSION >= 30
1311  }
1312 
1314  {
1315 #if DALI_GLES_VERSION >= 30
1316  return glClientWaitSync(sync,flags,timeout);
1317 #else
1318  return 0;
1319 #endif // DALI_GLES_VERSION >= 30
1320  }
1321 
1322  void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1323  {
1324 #if DALI_GLES_VERSION >= 30
1325  glWaitSync(sync,flags,timeout);
1326 #endif // DALI_GLES_VERSION >= 30
1327  }
1328 
1329  void GetInteger64v(GLenum pname, GLint64* params)
1330  {
1331 #if DALI_GLES_VERSION >= 30
1332  glGetInteger64v(pname,params);
1333 #endif // DALI_GLES_VERSION >= 30
1334  }
1335 
1336  void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
1337  {
1338 #if DALI_GLES_VERSION >= 30
1339  glGetSynciv(sync,pname,bufSize,length,values);
1340 #endif // DALI_GLES_VERSION >= 30
1341  }
1342 
1343  void GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
1344  {
1345 #if DALI_GLES_VERSION >= 30
1346  glGetInteger64i_v(target,index,data);
1347 #endif // DALI_GLES_VERSION >= 30
1348  }
1349 
1350  void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
1351  {
1352 #if DALI_GLES_VERSION >= 30
1353  glGetBufferParameteri64v(target,pname,params);
1354 #endif // DALI_GLES_VERSION >= 30
1355  }
1356 
1357  void GenSamplers(GLsizei count, GLuint* samplers)
1358  {
1359 #if DALI_GLES_VERSION >= 30
1360  glGenSamplers(count,samplers);
1361 #endif // DALI_GLES_VERSION >= 30
1362  }
1363 
1364  void DeleteSamplers(GLsizei count, const GLuint* samplers)
1365  {
1366 #if DALI_GLES_VERSION >= 30
1367  glDeleteSamplers(count,samplers);
1368 #endif // DALI_GLES_VERSION >= 30
1369  }
1370 
1372  {
1373 #if DALI_GLES_VERSION >= 30
1374  return glIsSampler(sampler);
1375 #else
1376  return 0;
1377 #endif // DALI_GLES_VERSION >= 30
1378  }
1379 
1380  void BindSampler(GLuint unit, GLuint sampler)
1381  {
1382 #if DALI_GLES_VERSION >= 30
1383  glBindSampler(unit,sampler);
1384 #endif // DALI_GLES_VERSION >= 30
1385  }
1386 
1387  void SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1388  {
1389 #if DALI_GLES_VERSION >= 30
1390  glSamplerParameteri(sampler,pname,param);
1391 #endif // DALI_GLES_VERSION >= 30
1392  }
1393 
1394  void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
1395  {
1396 #if DALI_GLES_VERSION >= 30
1397  glSamplerParameteriv(sampler,pname,param);
1398 #endif // DALI_GLES_VERSION >= 30
1399  }
1400 
1401  void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1402  {
1403 #if DALI_GLES_VERSION >= 30
1404  glSamplerParameterf(sampler,pname,param);
1405 #endif // DALI_GLES_VERSION >= 30
1406  }
1407 
1408  void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
1409  {
1410 #if DALI_GLES_VERSION >= 30
1411  glSamplerParameterfv(sampler,pname,param);
1412 #endif // DALI_GLES_VERSION >= 30
1413  }
1414 
1415  void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
1416  {
1417 #if DALI_GLES_VERSION >= 30
1418  glGetSamplerParameteriv(sampler,pname,params);
1419 #endif // DALI_GLES_VERSION >= 30
1420  }
1421 
1422  void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
1423  {
1424 #if DALI_GLES_VERSION >= 30
1425  glGetSamplerParameterfv(sampler,pname,params);
1426 #endif // DALI_GLES_VERSION >= 30
1427  }
1428 
1429  void VertexAttribDivisor(GLuint index, GLuint divisor)
1430  {
1431 #if DALI_GLES_VERSION >= 30
1432  glVertexAttribDivisor(index,divisor);
1433 #endif // DALI_GLES_VERSION >= 30
1434  }
1435 
1437  {
1438 #if DALI_GLES_VERSION >= 30
1439  glBindTransformFeedback(target,id);
1440 #endif // DALI_GLES_VERSION >= 30
1441  }
1442 
1444  {
1445 #if DALI_GLES_VERSION >= 30
1446  glDeleteTransformFeedbacks(n,ids);
1447 #endif // DALI_GLES_VERSION >= 30
1448  }
1449 
1451  {
1452 #if DALI_GLES_VERSION >= 30
1453  glGenTransformFeedbacks(n,ids);
1454 #endif // DALI_GLES_VERSION >= 30
1455  }
1456 
1458  {
1459 #if DALI_GLES_VERSION >= 30
1460  return glIsTransformFeedback(id);
1461 #else
1462  return 0;
1463 #endif // DALI_GLES_VERSION >= 30
1464  }
1465 
1467  {
1468 #if DALI_GLES_VERSION >= 30
1469  glPauseTransformFeedback();
1470 #endif // DALI_GLES_VERSION >= 30
1471  }
1472 
1474  {
1475 #if DALI_GLES_VERSION >= 30
1476  glResumeTransformFeedback();
1477 #endif // DALI_GLES_VERSION >= 30
1478  }
1479 
1480  void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
1481  {
1482 #if DALI_GLES_VERSION >= 30
1483  // if OpenGL ES 2.0 compatibility is need this can be implemented with
1484  // glGetProgramBinaryOES
1485  glGetProgramBinary(program,bufSize,length,binaryFormat,binary);
1486 #else
1487  mGlExtensions.GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
1488 #endif // DALI_GLES_VERSION >= 30
1489  }
1490 
1491  void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
1492  {
1493 #if DALI_GLES_VERSION >= 30
1494  // if OpenGL ES 2.0 compatibility is need this can be implemented with
1495  // glProgramBinaryOES
1496  glProgramBinary(program,binaryFormat,binary,length);
1497 #else
1498  mGlExtensions.ProgramBinaryOES(program, binaryFormat, binary, length);
1499 #endif // DALI_GLES_VERSION >= 30
1500  }
1501 
1502  void ProgramParameteri(GLuint program, GLenum pname, GLint value)
1503  {
1504 #if DALI_GLES_VERSION >= 30
1505  glProgramParameteri(program,pname,value);
1506 #endif // DALI_GLES_VERSION >= 30
1507  }
1508 
1509  void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
1510  {
1511 #if DALI_GLES_VERSION >= 30
1512  // if OpenGL ES 2.0 compatibility is need this can be implemented with
1513  // glDiscardFramebufferEXT
1514  glInvalidateFramebuffer(target,numAttachments,attachments);
1515 #endif // DALI_GLES_VERSION >= 30
1516  }
1517 
1518  void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1519  {
1520 #if DALI_GLES_VERSION >= 30
1521  glInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height);
1522 #endif // DALI_GLES_VERSION >= 30
1523  }
1524 
1525  void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1526  {
1527 #if DALI_GLES_VERSION >= 30
1528  glTexStorage2D(target,levels,internalformat,width,height);
1529 #endif // DALI_GLES_VERSION >= 30
1530  }
1531 
1532  void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
1533  {
1534 #if DALI_GLES_VERSION >= 30
1535  glTexStorage3D(target,levels,internalformat,width,height,depth);
1536 #endif // DALI_GLES_VERSION >= 30
1537  }
1538 
1539  void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
1540  {
1541 #if DALI_GLES_VERSION >= 30
1542  glGetInternalformativ(target,internalformat,pname,bufSize,params);
1543 #endif // DALI_GLES_VERSION >= 30
1544  }
1545 
1546 private:
1548 
1549 };
1550 
1551 } // namespace Adaptor
1552 
1553 } // namespace Internal
1554 
1555 } // namespace Dali
1556 
1557 #endif // __DALI_INTERNAL_GL_IMPLEMENTATION_H__
Dali Docs Home
Read more about Dali