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) 2021 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 namespace Internal
  31 {
  32 namespace Adaptor
  33 {
  34 class Gles3Implementation : public GlesAbstraction
  35 {
  36 public:
  37   Gles3Implementation()
  38   {
  39   }
  40
  41   ~Gles3Implementation() override
  42   {
  43   }
  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