dali/internal/graphics/gles/gles3-implementation.h

   1 #ifndef DALI_INTERNAL_GLES3_IMPLEMENTATION_H
   2 #define DALI_INTERNAL_GLES3_IMPLEMENTATION_H
   3
   4 /*
   5  * Copyright (c) 2019 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 <GLES3/gl3.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/internal/graphics/gles/gles-abstraction.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 namespace Adaptor
  34 {
  35
  36 class Gles3Implementation : public GlesAbstraction
  37 {
  38
  39 public:
  40   Gles3Implementation() {}
  41
  42   ~Gles3Implementation() override {}
  43
  44   void ReadBuffer( GLenum mode ) override
  45   {
  46     glReadBuffer( mode );
  47   }
  48
  49   void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices ) override
  50   {
  51     glDrawRangeElements( mode, start, end, count, type, indices );
  52   }
  53
  54   void TexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) override
  55   {
  56     glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
  57   }
  58
  59   void TexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels ) override
  60   {
  61     glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
  62   }
  63
  64   void CopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) override
  65   {
  66     glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
  67   }
  68
  69   void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data ) override
  70   {
  71     glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
  72   }
  73
  74   void CompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data ) override
  75   {
  76     glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
  77   }
  78
  79   void GenQueries( GLsizei n, GLuint* ids ) override
  80   {
  81     glGenQueries( n, ids );
  82   }
  83
  84   void DeleteQueries( GLsizei n, const GLuint* ids ) override
  85   {
  86     glDeleteQueries( n, ids );
  87   }
  88
  89   GLboolean IsQuery( GLuint id ) override
  90   {
  91     return glIsQuery( id );
  92   }
  93
  94   void BeginQuery( GLenum target, GLuint id ) override
  95   {
  96     glBeginQuery( target, id );
  97   }
  98
  99   void EndQuery( GLenum target ) override
 100   {
 101     glEndQuery( target );
 102   }
 103
 104   void GetQueryiv( GLenum target, GLenum pname, GLint* params ) override
 105   {
 106     glGetQueryiv( target, pname, params );
 107   }
 108
 109   void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) override
 110   {
 111     glGetQueryObjectuiv( id, pname, params );
 112   }
 113
 114   GLboolean UnmapBuffer( GLenum target ) override
 115   {
 116     return glUnmapBuffer( target );
 117   }
 118
 119   void GetBufferPointerv( GLenum target, GLenum pname, GLvoid** params ) override
 120   {
 121     glGetBufferPointerv( target, pname, params );
 122   }
 123
 124   void DrawBuffers( GLsizei n, const GLenum* bufs ) override
 125   {
 126     glDrawBuffers( n, bufs );
 127   }
 128
 129   void UniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 130   {
 131     glUniformMatrix2x3fv( location, count, transpose, value );
 132   }
 133
 134   void UniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 135   {
 136     glUniformMatrix3x2fv( location, count, transpose, value );
 137   }
 138
 139   void UniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 140   {
 141     glUniformMatrix2x4fv( location, count, transpose, value );
 142   }
 143
 144   void UniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 145   {
 146     glUniformMatrix4x2fv( location, count, transpose, value );
 147   }
 148
 149   void UniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 150   {
 151     glUniformMatrix3x4fv( location, count, transpose, value );
 152   }
 153
 154   void UniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
 155   {
 156     glUniformMatrix4x3fv( location, count, transpose, value );
 157   }
 158
 159   void BlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) override
 160   {
 161     glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 162   }
 163
 164   void RenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) override
 165   {
 166     glRenderbufferStorageMultisample( target, samples, internalformat, width, height );
 167   }
 168
 169   void FramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) override
 170   {
 171     glFramebufferTextureLayer( target, attachment, texture, level, layer );
 172   }
 173
 174   GLvoid* MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) override
 175   {
 176     return glMapBufferRange( target, offset, length, access );
 177   }
 178
 179   void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) override
 180   {
 181     glFlushMappedBufferRange( target, offset, length );
 182   }
 183
 184   void BindVertexArray( GLuint array ) override
 185   {
 186     glBindVertexArray( array );
 187   }
 188
 189   void DeleteVertexArrays( GLsizei n, const GLuint* arrays ) override
 190   {
 191     glDeleteVertexArrays( n, arrays );
 192   }
 193
 194   void GenVertexArrays( GLsizei n, GLuint* arrays ) override
 195   {
 196     glGenVertexArrays( n, arrays );
 197   }
 198
 199   GLboolean IsVertexArray( GLuint array ) override
 200   {
 201     return glIsVertexArray( array );
 202   }
 203
 204   void GetIntegeri_v( GLenum target, GLuint index, GLint* data ) override
 205   {
 206     glGetIntegeri_v( target, index, data );
 207   }
 208
 209   void BeginTransformFeedback( GLenum primitiveMode ) override
 210   {
 211     glBeginTransformFeedback( primitiveMode );
 212   }
 213
 214   void EndTransformFeedback( void ) override
 215   {
 216     glEndTransformFeedback();
 217   }
 218
 219   void BindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) override
 220   {
 221     glBindBufferRange( target, index, buffer, offset, size );
 222   }
 223
 224   void BindBufferBase( GLenum target, GLuint index, GLuint buffer ) override
 225   {
 226     glBindBufferBase( target, index, buffer );
 227   }
 228
 229   void TransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode ) override
 230   {
 231     glTransformFeedbackVaryings( program, count, varyings, bufferMode );
 232   }
 233
 234   void GetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) override
 235   {
 236     glGetTransformFeedbackVarying( program, index, bufSize, length, size, type, name );
 237   }
 238
 239   void VertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) override
 240   {
 241     glVertexAttribIPointer( index, size, type, stride, pointer );
 242   }
 243
 244   void GetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) override
 245   {
 246     glGetVertexAttribIiv( index, pname, params );
 247   }
 248
 249   void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) override
 250   {
 251     glGetVertexAttribIuiv( index, pname, params );
 252   }
 253
 254   void VertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) override
 255   {
 256     glVertexAttribI4i( index, x, y, z, w );
 257   }
 258
 259   void VertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) override
 260   {
 261     glVertexAttribI4ui( index, x, y, z, w );
 262   }
 263
 264   void VertexAttribI4iv( GLuint index, const GLint* v ) override
 265   {
 266     glVertexAttribI4iv( index, v );
 267   }
 268
 269   void VertexAttribI4uiv( GLuint index, const GLuint* v ) override
 270   {
 271     glVertexAttribI4uiv( index, v );
 272   }
 273
 274   void GetUniformuiv( GLuint program, GLint location, GLuint* params ) override
 275   {
 276     glGetUniformuiv( program, location, params );
 277   }
 278
 279   GLint GetFragDataLocation( GLuint program, const GLchar *name ) override
 280   {
 281     return glGetFragDataLocation( program, name );
 282   }
 283
 284   void Uniform1ui( GLint location, GLuint v0 ) override
 285   {
 286     glUniform1ui( location, v0 );
 287   }
 288
 289   void Uniform2ui( GLint location, GLuint v0, GLuint v1 ) override
 290   {
 291     glUniform2ui( location, v0, v1 );
 292   }
 293
 294   void Uniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) override
 295   {
 296     glUniform3ui( location, v0, v1, v2 );
 297   }
 298
 299   void Uniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) override
 300   {
 301     glUniform4ui( location, v0, v1, v2, v3 );
 302   }
 303
 304   void Uniform1uiv( GLint location, GLsizei count, const GLuint* value ) override
 305   {
 306     glUniform1uiv( location, count, value );
 307   }
 308
 309   void Uniform2uiv( GLint location, GLsizei count, const GLuint* value ) override
 310   {
 311     glUniform2uiv( location, count, value );
 312   }
 313
 314   void Uniform3uiv( GLint location, GLsizei count, const GLuint* value ) override
 315   {
 316     glUniform3uiv( location, count, value );
 317   }
 318
 319   void Uniform4uiv( GLint location, GLsizei count, const GLuint* value ) override
 320   {
 321     glUniform4uiv( location, count, value );
 322   }
 323
 324   void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) override
 325   {
 326     glClearBufferiv( buffer, drawbuffer, value );
 327   }
 328
 329   void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) override
 330   {
 331     glClearBufferuiv( buffer, drawbuffer, value );
 332   }
 333
 334   void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) override
 335   {
 336     glClearBufferfv( buffer, drawbuffer, value );
 337   }
 338
 339   void ClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) override
 340   {
 341     glClearBufferfi( buffer, drawbuffer, depth, stencil );
 342   }
 343
 344   const GLubyte* GetStringi( GLenum name, GLuint index ) override
 345   {
 346     return glGetStringi( name, index );
 347   }
 348
 349   void CopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) override
 350   {
 351     glCopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size );
 352   }
 353
 354   void GetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices ) override
 355   {
 356     glGetUniformIndices( program, uniformCount, uniformNames, uniformIndices );
 357   }
 358
 359   void GetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params ) override
 360   {
 361     glGetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params );
 362   }
 363
 364   GLuint GetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) override
 365   {
 366     return glGetUniformBlockIndex( program, uniformBlockName );
 367   }
 368
 369   void GetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) override
 370   {
 371     glGetActiveUniformBlockiv( program, uniformBlockIndex, pname, params );
 372   }
 373
 374   void GetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName ) override
 375   {
 376     glGetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName );
 377   }
 378
 379   void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) override
 380   {
 381     glUniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding );
 382   }
 383
 384   void DrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instanceCount ) override
 385   {
 386     glDrawArraysInstanced( mode, first, count, instanceCount );
 387   }
 388
 389   void DrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount ) override
 390   {
 391     glDrawElementsInstanced( mode, count, type, indices, instanceCount );
 392   }
 393
 394   GLsync FenceSync( GLenum condition, GLbitfield flags ) override
 395   {
 396     return glFenceSync( condition, flags );
 397   }
 398
 399   GLboolean IsSync( GLsync sync ) override
 400   {
 401     return glIsSync( sync );
 402   }
 403
 404   void DeleteSync( GLsync sync ) override
 405   {
 406     glDeleteSync( sync );
 407   }
 408
 409   GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
 410   {
 411     return glClientWaitSync( sync, flags, timeout );
 412   }
 413
 414   void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
 415   {
 416     glWaitSync( sync, flags, timeout );
 417   }
 418
 419   void GetInteger64v( GLenum pname, GLint64* params ) override
 420   {
 421     glGetInteger64v( pname, params );
 422   }
 423
 424   void GetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) override
 425   {
 426     glGetSynciv( sync, pname, bufSize, length, values );
 427   }
 428
 429   void GetInteger64i_v( GLenum target, GLuint index, GLint64* data ) override
 430   {
 431     glGetInteger64i_v( target, index, data );
 432   }
 433
 434   void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) override
 435   {
 436     glGetBufferParameteri64v( target, pname, params );
 437   }
 438
 439   void GenSamplers( GLsizei count, GLuint* samplers ) override
 440   {
 441     glGenSamplers( count, samplers );
 442   }
 443
 444   void DeleteSamplers( GLsizei count, const GLuint* samplers ) override
 445   {
 446     glDeleteSamplers( count, samplers );
 447   }
 448
 449   GLboolean IsSampler( GLuint sampler ) override
 450   {
 451     return glIsSampler( sampler );
 452   }
 453
 454   void BindSampler( GLuint unit, GLuint sampler ) override
 455   {
 456     glBindSampler( unit, sampler );
 457   }
 458
 459   void SamplerParameteri( GLuint sampler, GLenum pname, GLint param ) override
 460   {
 461     glSamplerParameteri( sampler, pname, param );
 462   }
 463
 464   void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) override
 465   {
 466     glSamplerParameteriv( sampler, pname, param );
 467   }
 468
 469   void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) override
 470   {
 471     glSamplerParameterf( sampler, pname, param );
 472   }
 473
 474   void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) override
 475   {
 476     glSamplerParameterfv( sampler, pname, param );
 477   }
 478
 479   void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) override
 480   {
 481     glGetSamplerParameteriv( sampler, pname, params );
 482   }
 483
 484   void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) override
 485   {
 486     glGetSamplerParameterfv( sampler, pname, params );
 487   }
 488
 489   void VertexAttribDivisor( GLuint index, GLuint divisor ) override
 490   {
 491     glVertexAttribDivisor( index, divisor );
 492   }
 493
 494   void BindTransformFeedback( GLenum target, GLuint id ) override
 495   {
 496     glBindTransformFeedback( target, id );
 497   }
 498
 499   void DeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) override
 500   {
 501     glDeleteTransformFeedbacks( n, ids );
 502   }
 503
 504   void GenTransformFeedbacks( GLsizei n, GLuint* ids ) override
 505   {
 506     glGenTransformFeedbacks( n, ids );
 507   }
 508
 509   GLboolean IsTransformFeedback( GLuint id ) override
 510   {
 511     return glIsTransformFeedback( id );
 512   }
 513
 514   void PauseTransformFeedback( void ) override
 515   {
 516     glPauseTransformFeedback();
 517   }
 518
 519   void ResumeTransformFeedback( void ) override
 520   {
 521     glResumeTransformFeedback();
 522   }
 523
 524   void GetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary ) override
 525   {
 526     glGetProgramBinary( program, bufSize, length, binaryFormat, binary );
 527   }
 528
 529   void ProgramBinary( GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length ) override
 530   {
 531     glProgramBinary( program, binaryFormat, binary, length );
 532   }
 533
 534   void ProgramParameteri( GLuint program, GLenum pname, GLint value ) override
 535   {
 536     glProgramParameteri( program, pname, value );
 537   }
 538
 539   void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) override
 540   {
 541     glInvalidateFramebuffer( target, numAttachments, attachments );
 542   }
 543
 544   void InvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) override
 545   {
 546     glInvalidateSubFramebuffer( target, numAttachments, attachments, x, y, width, height );
 547   }
 548
 549   void TexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) override
 550   {
 551     glTexStorage2D( target, levels, internalformat, width, height );
 552   }
 553
 554   void TexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) override
 555   {
 556     glTexStorage3D( target, levels, internalformat, width, height, depth );
 557   }
 558
 559   void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) override
 560   {
 561     glGetInternalformativ( target, internalformat, pname, bufSize, params );
 562   }
 563 };
 564
 565 } // namespace Adaptor
 566
 567 } // namespace Internal
 568
 569 } // namespace Dali
 570
 571 #endif // DALI_INTERNAL_GLES3_IMPLEMENTATION_H