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