gfx/gl/SkiaGLGlue.cpp

   1 /* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "skia/GrContext.h"
   7 #include "skia/GrGLInterface.h"
   8 #include "mozilla/gfx/2D.h"
   9 #include "mozilla/ThreadLocal.h"
  10 #include "mozilla/DebugOnly.h"
  11
  12 /* SkPostConfig.h includes windows.h, which includes windef.h
  13  * which redefines min/max. We don't want that. */
  14 #ifdef _WIN32
  15 #undef min
  16 #undef max
  17 #endif
  18
  19 #include "GLContext.h"
  20 #include "SkiaGLGlue.h"
  21
  22 using mozilla::gl::GLContext;
  23 using mozilla::gl::GLFeature;
  24 using mozilla::gl::SkiaGLGlue;
  25 using mozilla::gfx::DrawTarget;
  26
  27 static mozilla::ThreadLocal<GLContext*> sGLContext;
  28
  29 extern "C" {
  30
  31 static void SetStaticGLContext(GLContext* context)
  32 {
  33     if (!sGLContext.initialized()) {
  34       mozilla::DebugOnly<bool> success = sGLContext.init();
  35       MOZ_ASSERT(success);
  36     }
  37
  38     sGLContext.set(context);
  39 }
  40
  41 void EnsureGLContext(const GrGLInterface* i)
  42 {
  43     const SkiaGLGlue* contextSkia = reinterpret_cast<const SkiaGLGlue*>(i->fCallbackData);
  44     MOZ_ASSERT(contextSkia);
  45     GLContext* gl = contextSkia->GetGLContext();
  46     gl->MakeCurrent();
  47     SetStaticGLContext(gl);
  48 }
  49
  50 // Core GL functions required by Ganesh
  51
  52 GrGLvoid glActiveTexture_mozilla(GrGLenum texture)
  53 {
  54     return sGLContext.get()->fActiveTexture(texture);
  55 }
  56
  57 GrGLvoid glAttachShader_mozilla(GrGLuint program, GrGLuint shader)
  58 {
  59     return sGLContext.get()->fAttachShader(program, shader);
  60 }
  61
  62 GrGLvoid glBindAttribLocation_mozilla(GrGLuint program, GrGLuint index, const GLchar* name)
  63 {
  64     return sGLContext.get()->fBindAttribLocation(program, index, name);
  65 }
  66
  67 GrGLvoid glBindBuffer_mozilla(GrGLenum target, GrGLuint buffer)
  68 {
  69     return sGLContext.get()->fBindBuffer(target, buffer);
  70 }
  71
  72 GrGLvoid glBindFramebuffer_mozilla(GrGLenum target, GrGLuint framebuffer)
  73 {
  74     return sGLContext.get()->fBindFramebuffer(target, framebuffer);
  75 }
  76
  77 GrGLvoid glBindRenderbuffer_mozilla(GrGLenum target, GrGLuint renderbuffer)
  78 {
  79     return sGLContext.get()->fBindRenderbuffer(target, renderbuffer);
  80 }
  81
  82 GrGLvoid glBindTexture_mozilla(GrGLenum target, GrGLuint texture)
  83 {
  84     return sGLContext.get()->fBindTexture(target, texture);
  85 }
  86
  87 GrGLvoid glBlendColor_mozilla(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha)
  88 {
  89     return sGLContext.get()->fBlendColor(red, green, blue, alpha);
  90 }
  91
  92 GrGLvoid glBlendFunc_mozilla(GrGLenum sfactor, GrGLenum dfactor)
  93 {
  94     return sGLContext.get()->fBlendFunc(sfactor, dfactor);
  95 }
  96
  97 GrGLvoid glBufferData_mozilla(GrGLenum target, GrGLsizeiptr size, const void* data, GrGLenum usage)
  98 {
  99     return sGLContext.get()->fBufferData(target, size, data, usage);
 100 }
 101
 102 GrGLvoid glBufferSubData_mozilla(GrGLenum target, GrGLintptr offset, GrGLsizeiptr size, const void* data)
 103 {
 104     return sGLContext.get()->fBufferSubData(target, offset, size, data);
 105 }
 106
 107 GrGLenum glCheckFramebufferStatus_mozilla(GrGLenum target)
 108 {
 109     return sGLContext.get()->fCheckFramebufferStatus(target);
 110 }
 111
 112 GrGLvoid glClear_mozilla(GrGLbitfield mask)
 113 {
 114     return sGLContext.get()->fClear(mask);
 115 }
 116
 117 GrGLvoid glClearColor_mozilla(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha)
 118 {
 119     return sGLContext.get()->fClearColor(red, green, blue, alpha);
 120 }
 121
 122 GrGLvoid glClearStencil_mozilla(GrGLint s)
 123 {
 124     return sGLContext.get()->fClearStencil(s);
 125 }
 126
 127 GrGLvoid glColorMask_mozilla(GrGLboolean red, GrGLboolean green, GrGLboolean blue, GrGLboolean alpha)
 128 {
 129     return sGLContext.get()->fColorMask(red, green, blue, alpha);
 130 }
 131
 132 GrGLvoid glCompileShader_mozilla(GrGLuint shader)
 133 {
 134     return sGLContext.get()->fCompileShader(shader);
 135 }
 136
 137 GrGLvoid glCopyTexSubImage2D_mozilla(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset,
 138                                      GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
 139 {
 140     return sGLContext.get()->fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 141 }
 142
 143 GrGLuint glCreateProgram_mozilla(void)
 144 {
 145     return sGLContext.get()->fCreateProgram();
 146 }
 147
 148 GrGLuint glCreateShader_mozilla(GrGLenum type)
 149 {
 150     return sGLContext.get()->fCreateShader(type);
 151 }
 152
 153 GrGLvoid glCullFace_mozilla(GrGLenum mode)
 154 {
 155     return sGLContext.get()->fCullFace(mode);
 156 }
 157
 158 GrGLvoid glDeleteBuffers_mozilla(GrGLsizei n, const GrGLuint* buffers)
 159 {
 160     return sGLContext.get()->fDeleteBuffers(n, buffers);
 161 }
 162
 163 GrGLvoid glDeleteFramebuffers_mozilla(GrGLsizei n, const GrGLuint* framebuffers)
 164 {
 165     return sGLContext.get()->fDeleteFramebuffers(n, framebuffers);
 166 }
 167
 168 GrGLvoid glDeleteProgram_mozilla(GrGLuint program)
 169 {
 170     return sGLContext.get()->fDeleteProgram(program);
 171 }
 172
 173 GrGLvoid glDeleteRenderbuffers_mozilla(GrGLsizei n, const GrGLuint* renderbuffers)
 174 {
 175     return sGLContext.get()->fDeleteRenderbuffers(n, renderbuffers);
 176 }
 177
 178 GrGLvoid glDeleteShader_mozilla(GrGLuint shader)
 179 {
 180     return sGLContext.get()->fDeleteShader(shader);
 181 }
 182
 183 GrGLvoid glDeleteTextures_mozilla(GrGLsizei n, const GrGLuint* textures)
 184 {
 185     return sGLContext.get()->fDeleteTextures(n, textures);
 186 }
 187
 188 GrGLvoid glDepthMask_mozilla(GrGLboolean flag)
 189 {
 190     return sGLContext.get()->fDepthMask(flag);
 191 }
 192
 193 GrGLvoid glDisable_mozilla(GrGLenum cap)
 194 {
 195     return sGLContext.get()->fDisable(cap);
 196 }
 197
 198 GrGLvoid glDisableVertexAttribArray_mozilla(GrGLuint index)
 199 {
 200     return sGLContext.get()->fDisableVertexAttribArray(index);
 201 }
 202
 203 GrGLvoid glDrawArrays_mozilla(GrGLenum mode, GrGLint first, GrGLsizei count)
 204 {
 205     return sGLContext.get()->fDrawArrays(mode, first, count);
 206 }
 207
 208 GrGLvoid glDrawElements_mozilla(GrGLenum mode, GrGLsizei count, GrGLenum type, const void* indices)
 209 {
 210     return sGLContext.get()->fDrawElements(mode, count, type, indices);
 211 }
 212
 213 GrGLvoid glEnable_mozilla(GrGLenum cap)
 214 {
 215     return sGLContext.get()->fEnable(cap);
 216 }
 217
 218 GrGLvoid glEnableVertexAttribArray_mozilla(GrGLuint index)
 219 {
 220     return sGLContext.get()->fEnableVertexAttribArray(index);
 221 }
 222
 223 GrGLvoid glFinish_mozilla()
 224 {
 225     return sGLContext.get()->fFinish();
 226 }
 227
 228 GrGLvoid glFlush_mozilla()
 229 {
 230     return sGLContext.get()->fFlush();
 231 }
 232
 233 GrGLvoid glFramebufferRenderbuffer_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer)
 234 {
 235     return sGLContext.get()->fFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 236 }
 237
 238 GrGLvoid glFramebufferTexture2D_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level)
 239 {
 240     return sGLContext.get()->fFramebufferTexture2D(target, attachment, textarget, texture, level);
 241 }
 242
 243 GrGLvoid glFrontFace_mozilla(GrGLenum mode)
 244 {
 245     return sGLContext.get()->fFrontFace(mode);
 246 }
 247
 248 GrGLvoid glGenBuffers_mozilla(GrGLsizei n, GrGLuint* buffers)
 249 {
 250     return sGLContext.get()->fGenBuffers(n, buffers);
 251 }
 252
 253 GrGLvoid glGenFramebuffers_mozilla(GrGLsizei n, GrGLuint* framebuffers)
 254 {
 255     return sGLContext.get()->fGenFramebuffers(n, framebuffers);
 256 }
 257
 258 GrGLvoid glGenRenderbuffers_mozilla(GrGLsizei n, GrGLuint* renderbuffers)
 259 {
 260     return sGLContext.get()->fGenRenderbuffers(n, renderbuffers);
 261 }
 262
 263 GrGLvoid glGenTextures_mozilla(GrGLsizei n, GrGLuint* textures)
 264 {
 265     return sGLContext.get()->fGenTextures(n, textures);
 266 }
 267
 268 GrGLvoid glGenerateMipmap_mozilla(GrGLenum target)
 269 {
 270     return sGLContext.get()->fGenerateMipmap(target);
 271 }
 272
 273 GrGLvoid glGetBufferParameteriv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
 274 {
 275     return sGLContext.get()->fGetBufferParameteriv(target, pname, params);
 276 }
 277
 278 GrGLvoid glGetFramebufferAttachmentParameteriv_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params)
 279 {
 280     return sGLContext.get()->fGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 281 }
 282
 283 GrGLenum glGetError_mozilla()
 284 {
 285     return sGLContext.get()->fGetError();
 286 }
 287
 288 GrGLvoid glGetIntegerv_mozilla(GrGLenum pname, GrGLint* params)
 289 {
 290     return sGLContext.get()->fGetIntegerv(pname, params);
 291 }
 292
 293 GrGLvoid glGetProgramInfoLog_mozilla(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, char* infolog)
 294 {
 295     return sGLContext.get()->fGetProgramInfoLog(program, bufsize, length, infolog);
 296 }
 297
 298 GrGLvoid glGetProgramiv_mozilla(GrGLuint program, GrGLenum pname, GrGLint* params)
 299 {
 300     return sGLContext.get()->fGetProgramiv(program, pname, params);
 301 }
 302
 303 GrGLvoid glGetRenderbufferParameteriv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
 304 {
 305     return sGLContext.get()->fGetRenderbufferParameteriv(target, pname, params);
 306 }
 307
 308 GrGLvoid glGetShaderInfoLog_mozilla(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length, char* infolog)
 309 {
 310     return sGLContext.get()->fGetShaderInfoLog(shader, bufsize, length, infolog);
 311 }
 312
 313 GrGLvoid glGetShaderiv_mozilla(GrGLuint shader, GrGLenum pname, GrGLint* params)
 314 {
 315     return sGLContext.get()->fGetShaderiv(shader, pname, params);
 316 }
 317
 318 const GLubyte* glGetString_mozilla(GrGLenum name)
 319 {
 320     // GLContext only exposes a OpenGL 2.0 style API, so we have to intercept a bunch
 321     // of checks that Ganesh makes to determine which capabilities are present
 322     // on the GL implementation and change them to match what GLContext actually exposes.
 323
 324     if (name == LOCAL_GL_VERSION) {
 325         if (sGLContext.get()->IsGLES()) {
 326             return reinterpret_cast<const GLubyte*>("OpenGL ES 2.0");
 327         } else {
 328             return reinterpret_cast<const GLubyte*>("2.0");
 329         }
 330     } else if (name == LOCAL_GL_EXTENSIONS) {
 331         // Only expose the bare minimum extensions we want to support to ensure a functional Ganesh
 332         // as GLContext only exposes certain extensions
 333         static bool extensionsStringBuilt = false;
 334         static char extensionsString[1024];
 335
 336         if (!extensionsStringBuilt) {
 337             extensionsString[0] = '\0';
 338
 339             if (sGLContext.get()->IsGLES()) {
 340                 // OES is only applicable to GLES2
 341                 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_packed_depth_stencil)) {
 342                     strcat(extensionsString, "GL_OES_packed_depth_stencil ");
 343                 }
 344
 345                 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_rgb8_rgba8)) {
 346                     strcat(extensionsString, "GL_OES_rgb8_rgba8 ");
 347                 }
 348
 349                 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_texture_npot)) {
 350                     strcat(extensionsString, "GL_OES_texture_npot ");
 351                 }
 352
 353                 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_vertex_array_object)) {
 354                     strcat(extensionsString, "GL_OES_vertex_array_object ");
 355                 }
 356
 357                 if (sGLContext.get()->IsSupported(GLFeature::standard_derivatives)) {
 358                     strcat(extensionsString, "GL_OES_standard_derivatives ");
 359                 }
 360             }
 361
 362             if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_texture_format_BGRA8888)) {
 363                 strcat(extensionsString, "GL_EXT_texture_format_BGRA8888 ");
 364             }
 365
 366             if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_packed_depth_stencil)) {
 367                 strcat(extensionsString, "GL_EXT_packed_depth_stencil ");
 368             }
 369
 370             if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_bgra)) {
 371                 strcat(extensionsString, "GL_EXT_bgra ");
 372             }
 373
 374             if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_read_format_bgra)) {
 375                 strcat(extensionsString, "GL_EXT_read_format_bgra ");
 376             }
 377
 378             extensionsStringBuilt = true;
 379 #ifdef DEBUG
 380             printf_stderr("Exported SkiaGL extensions: %s\n", extensionsString);
 381 #endif
 382         }
 383
 384         return reinterpret_cast<const GLubyte*>(extensionsString);
 385
 386     } else if (name == LOCAL_GL_SHADING_LANGUAGE_VERSION) {
 387         if (sGLContext.get()->IsGLES()) {
 388             return reinterpret_cast<const GLubyte*>("OpenGL ES GLSL ES 1.0");
 389         } else {
 390             return reinterpret_cast<const GLubyte*>("1.10");
 391         }
 392     }
 393
 394     return sGLContext.get()->fGetString(name);
 395 }
 396
 397 GrGLint glGetUniformLocation_mozilla(GrGLuint program, const char* name)
 398 {
 399     return sGLContext.get()->fGetUniformLocation(program, name);
 400 }
 401
 402 GrGLvoid glLineWidth_mozilla(GrGLfloat width)
 403 {
 404     return sGLContext.get()->fLineWidth(width);
 405 }
 406
 407 GrGLvoid glLinkProgram_mozilla(GrGLuint program)
 408 {
 409     return sGLContext.get()->fLinkProgram(program);
 410 }
 411
 412 GrGLvoid glPixelStorei_mozilla(GrGLenum pname, GrGLint param)
 413 {
 414     return sGLContext.get()->fPixelStorei(pname, param);
 415 }
 416
 417 GrGLvoid glReadPixels_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height,
 418                               GrGLenum format, GrGLenum type, void* pixels)
 419 {
 420     return sGLContext.get()->fReadPixels(x, y, width, height,
 421                                    format, type, pixels);
 422 }
 423
 424 GrGLvoid glRenderbufferStorage_mozilla(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height)
 425 {
 426     return sGLContext.get()->fRenderbufferStorage(target, internalformat, width, height);
 427 }
 428
 429 GrGLvoid glScissor_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
 430 {
 431     return sGLContext.get()->fScissor(x, y, width, height);
 432 }
 433
 434 GrGLvoid glShaderSource_mozilla(GrGLuint shader, GrGLsizei count, const char** str, const GrGLint* length)
 435 {
 436     return sGLContext.get()->fShaderSource(shader, count, str, length);
 437 }
 438
 439 GrGLvoid glStencilFunc_mozilla(GrGLenum func, GrGLint ref, GrGLuint mask)
 440 {
 441     return sGLContext.get()->fStencilFunc(func, ref, mask);
 442 }
 443
 444 GrGLvoid glStencilMask_mozilla(GrGLuint mask)
 445 {
 446     return sGLContext.get()->fStencilMask(mask);
 447 }
 448
 449 GrGLvoid glStencilOp_mozilla(GrGLenum fail, GrGLenum zfail, GrGLenum zpass)
 450 {
 451     return sGLContext.get()->fStencilOp(fail, zfail, zpass);
 452 }
 453
 454 GrGLvoid glTexImage2D_mozilla(GrGLenum target, GrGLint level, GrGLint internalformat,
 455                               GrGLsizei width, GrGLsizei height, GrGLint border,
 456                               GrGLenum format, GrGLenum type, const void* pixels)
 457 {
 458     return sGLContext.get()->fTexImage2D(target, level, internalformat,
 459                                    width, height, border,
 460                                    format, type, pixels);
 461 }
 462
 463 GrGLvoid glTexParameteri_mozilla(GrGLenum target, GrGLenum pname, GrGLint param)
 464 {
 465     return sGLContext.get()->fTexParameteri(target, pname, param);
 466 }
 467
 468 GrGLvoid glTexParameteriv_mozilla(GrGLenum target, GrGLenum pname, const GrGLint* params)
 469 {
 470     return sGLContext.get()->fTexParameteriv(target, pname, params);
 471 }
 472
 473 GrGLvoid glTexSubImage2D_mozilla(GrGLenum target, GrGLint level,
 474                                  GrGLint xoffset, GrGLint yoffset,
 475                                  GrGLsizei width, GrGLsizei height,
 476                                  GrGLenum format, GrGLenum type, const void* pixels)
 477 {
 478     return sGLContext.get()->fTexSubImage2D(target, level,
 479                                       xoffset, yoffset,
 480                                       width, height,
 481                                       format, type, pixels);
 482 }
 483
 484 GrGLvoid glUniform1f_mozilla(GrGLint location, GrGLfloat v)
 485 {
 486     return sGLContext.get()->fUniform1f(location, v);
 487 }
 488
 489 GrGLvoid glUniform1i_mozilla(GrGLint location, GrGLint v)
 490 {
 491     return sGLContext.get()->fUniform1i(location, v);
 492 }
 493
 494 GrGLvoid glUniform1fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
 495 {
 496     return sGLContext.get()->fUniform1fv(location, count, v);
 497 }
 498
 499 GrGLvoid glUniform1iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
 500 {
 501     return sGLContext.get()->fUniform1iv(location, count, v);
 502 }
 503
 504 GrGLvoid glUniform2f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1)
 505 {
 506     return sGLContext.get()->fUniform2f(location, v0, v1);
 507 }
 508
 509 GrGLvoid glUniform2i_mozilla(GrGLint location, GrGLint v0, GrGLint v1)
 510 {
 511     return sGLContext.get()->fUniform2i(location, v0, v1);
 512 }
 513
 514 GrGLvoid glUniform2fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
 515 {
 516     return sGLContext.get()->fUniform2fv(location, count, v);
 517 }
 518
 519 GrGLvoid glUniform2iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
 520 {
 521     return sGLContext.get()->fUniform2iv(location, count, v);
 522 }
 523
 524 GrGLvoid glUniform3f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2)
 525 {
 526     return sGLContext.get()->fUniform3f(location, v0, v1, v2);
 527 }
 528
 529 GrGLvoid glUniform3i_mozilla(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2)
 530 {
 531     return sGLContext.get()->fUniform3i(location, v0, v1, v2);
 532 }
 533
 534 GrGLvoid glUniform3fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
 535 {
 536     return sGLContext.get()->fUniform3fv(location, count, v);
 537 }
 538
 539 GrGLvoid glUniform3iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
 540 {
 541     return sGLContext.get()->fUniform3iv(location, count, v);
 542 }
 543
 544 GrGLvoid glUniform4f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2, GrGLfloat v3)
 545 {
 546     return sGLContext.get()->fUniform4f(location, v0, v1, v2, v3);
 547 }
 548
 549 GrGLvoid glUniform4i_mozilla(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3)
 550 {
 551     return sGLContext.get()->fUniform4i(location, v0, v1, v2, v3);
 552 }
 553
 554 GrGLvoid glUniform4fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
 555 {
 556     return sGLContext.get()->fUniform4fv(location, count, v);
 557 }
 558
 559 GrGLvoid glUniform4iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
 560 {
 561     return sGLContext.get()->fUniform4iv(location, count, v);
 562 }
 563
 564 GrGLvoid glUniformMatrix2fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
 565 {
 566     return sGLContext.get()->fUniformMatrix2fv(location, count, transpose, value);
 567 }
 568
 569 GrGLvoid glUniformMatrix3fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
 570 {
 571     return sGLContext.get()->fUniformMatrix3fv(location, count, transpose, value);
 572 }
 573
 574 GrGLvoid glUniformMatrix4fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
 575 {
 576     return sGLContext.get()->fUniformMatrix4fv(location, count, transpose, value);
 577 }
 578
 579 GrGLvoid glUseProgram_mozilla(GrGLuint program)
 580 {
 581     return sGLContext.get()->fUseProgram(program);
 582 }
 583
 584 GrGLvoid glVertexAttrib4fv_mozilla(GrGLuint index, const GrGLfloat* values)
 585 {
 586     return sGLContext.get()->fVertexAttrib4fv(index, values);
 587 }
 588
 589 GrGLvoid glVertexAttribPointer_mozilla(GrGLuint index, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, const void* ptr)
 590 {
 591     return sGLContext.get()->fVertexAttribPointer(index, size, type, normalized, stride, ptr);
 592 }
 593
 594 GrGLvoid glViewport_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
 595 {
 596     return sGLContext.get()->fViewport(x, y, width, height);
 597 }
 598
 599 // Required if the bindings are GLES2 or desktop OpenGL 2.0
 600
 601 GrGLvoid glStencilFuncSeparate_mozilla(GrGLenum frontfunc, GrGLenum backfunc, GrGLint ref, GrGLuint mask)
 602 {
 603     return sGLContext.get()->fStencilFuncSeparate(frontfunc, backfunc, ref, mask);
 604 }
 605
 606 GrGLvoid glStencilMaskSeparate_mozilla(GrGLenum face, GrGLuint mask)
 607 {
 608     return sGLContext.get()->fStencilMaskSeparate(face, mask);
 609 }
 610
 611 GrGLvoid glStencilOpSeparate_mozilla(GrGLenum face, GrGLenum sfail, GrGLenum dpfail, GrGLenum dppass)
 612 {
 613     return sGLContext.get()->fStencilOpSeparate(face, sfail, dpfail, dppass);
 614 }
 615
 616 // Not in GLES2
 617
 618 GrGLvoid glGetTexLevelParameteriv_mozilla(GrGLenum target, GrGLint level, GrGLenum pname, GrGLint *params)
 619 {
 620     return sGLContext.get()->fGetTexLevelParameteriv(target, level, pname, params);
 621 }
 622
 623 GrGLvoid glDrawBuffer_mozilla(GrGLenum mode)
 624 {
 625     return sGLContext.get()->fDrawBuffer(mode);
 626 }
 627
 628 GrGLvoid glReadBuffer_mozilla(GrGLenum mode)
 629 {
 630     return sGLContext.get()->fReadBuffer(mode);
 631 }
 632
 633 // Desktop OpenGL version >= 1.5
 634
 635 GrGLvoid glGenQueries_mozilla(GrGLsizei n, GrGLuint* ids)
 636 {
 637     return sGLContext.get()->fGenQueries(n, ids);
 638 }
 639
 640 GrGLvoid glDeleteQueries_mozilla(GrGLsizei n, const GrGLuint* ids)
 641 {
 642     return sGLContext.get()->fDeleteQueries(n, ids);
 643 }
 644
 645 GrGLvoid glBeginQuery_mozilla(GrGLenum target, GrGLuint id)
 646 {
 647     return sGLContext.get()->fBeginQuery(target, id);
 648 }
 649
 650 GrGLvoid glEndQuery_mozilla(GrGLenum target)
 651 {
 652     return sGLContext.get()->fEndQuery(target);
 653 }
 654
 655 GrGLvoid glGetQueryiv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
 656 {
 657     return sGLContext.get()->fGetQueryiv(target, pname, params);
 658 }
 659
 660 GrGLvoid glGetQueryObjectiv_mozilla(GrGLuint id, GrGLenum pname, GrGLint* params)
 661 {
 662     return sGLContext.get()->fGetQueryObjectiv(id, pname, params);
 663 }
 664
 665 GrGLvoid glGetQueryObjectuiv_mozilla(GrGLuint id, GrGLenum pname, GrGLuint* params)
 666 {
 667     return sGLContext.get()->fGetQueryObjectuiv(id, pname, params);
 668 }
 669
 670 // Desktop OpenGL version >= 2.0
 671
 672 GrGLvoid glDrawBuffers_mozilla(GrGLsizei n, const GrGLenum* bufs)
 673 {
 674     return sGLContext.get()->fDrawBuffers(n, bufs);
 675 }
 676
 677 // GLContext supports glMapBuffer on everything (GL_OES_mapbuffer)
 678
 679 GrGLvoid* glMapBuffer_mozilla(GrGLenum target, GrGLenum access)
 680 {
 681     return sGLContext.get()->fMapBuffer(target, access);
 682 }
 683
 684 GrGLboolean glUnmapBuffer_mozilla(GrGLenum target)
 685 {
 686     return sGLContext.get()->fUnmapBuffer(target);
 687 }
 688
 689 // GLContext supports glCompressedTexImage2D (GL_ARB_texture_compression)
 690
 691 GrGLvoid glCompressedTexImage2D_mozilla(GrGLenum target, GrGLint level, GrGLenum internalformat,
 692                                         GrGLsizei width, GrGLsizei height, GrGLint border,
 693                                         GrGLsizei imageSize, const GrGLvoid* pixels)
 694 {
 695     return sGLContext.get()->fCompressedTexImage2D(target, level, internalformat,
 696                                              width, height, border,
 697                                              imageSize, pixels);
 698 }
 699
 700 // GLContext supports glBlitFramebuffer/glRenderbufferStorageMultisample (GL_ARB_framebuffer_object)
 701
 702 GrGLvoid glRenderbufferStorageMultisample_mozilla(GrGLenum target, GrGLsizei samples, GrGLenum internalformat,
 703                                                   GrGLsizei width, GrGLsizei height)
 704 {
 705     return sGLContext.get()->fRenderbufferStorageMultisample(target, samples, internalformat,
 706                                                        width, height);
 707 }
 708
 709 GrGLvoid glBlitFramebuffer_mozilla(GrGLint srcX0, GrGLint srcY0,
 710                                    GrGLint srcX1, GrGLint srcY1,
 711                                    GrGLint dstX0, GrGLint dstY0,
 712                                    GrGLint dstX1, GrGLint dstY1,
 713                                    GrGLbitfield mask, GrGLenum filter) {
 714     return sGLContext.get()->fBlitFramebuffer(srcX0, srcY0,
 715                                         srcX1, srcY1,
 716                                         dstX0, dstY0,
 717                                         dstX1, dstY1,
 718                                         mask, filter);
 719 }
 720
 721 GrGLvoid glBindVertexArray_mozilla(GrGLuint array) {
 722     return sGLContext.get()->fBindVertexArray(array);
 723 }
 724
 725 GrGLvoid glDeleteVertexArrays_mozilla(GrGLsizei n, const GrGLuint *arrays) {
 726     return sGLContext.get()->fDeleteVertexArrays(n, arrays);
 727 }
 728
 729 GrGLvoid glGenVertexArrays_mozilla(GrGLsizei n, GrGLuint *arrays) {
 730     return sGLContext.get()->fGenVertexArrays(n, arrays);
 731 }
 732
 733 } // extern "C"
 734
 735 static GrGLInterface* CreateGrGLInterfaceFromGLContext(GLContext* context)
 736 {
 737     SetStaticGLContext(context);
 738
 739     GrGLInterface* i = new GrGLInterface();
 740     i->fCallback = EnsureGLContext;
 741     i->fCallbackData = 0; // must be later initialized to be a valid DrawTargetSkia* pointer
 742
 743     context->MakeCurrent();
 744
 745     // We support both desktop GL and GLES2
 746     if (context->IsGLES()) {
 747         i->fStandard = kGLES_GrGLStandard;
 748     } else {
 749         i->fStandard = kGL_GrGLStandard;
 750     }
 751
 752     GrGLExtensions extensions;
 753     if (!extensions.init(i->fStandard, glGetString_mozilla, NULL, glGetIntegerv_mozilla)) {
 754         delete i;
 755         return nullptr;
 756     }
 757
 758     i->fExtensions.swap(&extensions);
 759
 760     // Core GL functions required by Ganesh
 761     i->fFunctions.fActiveTexture = glActiveTexture_mozilla;
 762     i->fFunctions.fAttachShader = glAttachShader_mozilla;
 763     i->fFunctions.fBindAttribLocation = glBindAttribLocation_mozilla;
 764     i->fFunctions.fBindBuffer = glBindBuffer_mozilla;
 765     i->fFunctions.fBindFramebuffer = glBindFramebuffer_mozilla;
 766     i->fFunctions.fBindRenderbuffer = glBindRenderbuffer_mozilla;
 767     i->fFunctions.fBindTexture = glBindTexture_mozilla;
 768     i->fFunctions.fBlendFunc = glBlendFunc_mozilla;
 769     i->fFunctions.fBlendColor = glBlendColor_mozilla;
 770     i->fFunctions.fBufferData = glBufferData_mozilla;
 771     i->fFunctions.fBufferSubData = glBufferSubData_mozilla;
 772     i->fFunctions.fCheckFramebufferStatus = glCheckFramebufferStatus_mozilla;
 773     i->fFunctions.fClear = glClear_mozilla;
 774     i->fFunctions.fClearColor = glClearColor_mozilla;
 775     i->fFunctions.fClearStencil = glClearStencil_mozilla;
 776     i->fFunctions.fColorMask = glColorMask_mozilla;
 777     i->fFunctions.fCompileShader = glCompileShader_mozilla;
 778     i->fFunctions.fCopyTexSubImage2D = glCopyTexSubImage2D_mozilla;
 779     i->fFunctions.fCreateProgram = glCreateProgram_mozilla;
 780     i->fFunctions.fCreateShader = glCreateShader_mozilla;
 781     i->fFunctions.fCullFace = glCullFace_mozilla;
 782     i->fFunctions.fDeleteBuffers = glDeleteBuffers_mozilla;
 783     i->fFunctions.fDeleteFramebuffers = glDeleteFramebuffers_mozilla;
 784     i->fFunctions.fDeleteProgram = glDeleteProgram_mozilla;
 785     i->fFunctions.fDeleteRenderbuffers = glDeleteRenderbuffers_mozilla;
 786     i->fFunctions.fDeleteShader = glDeleteShader_mozilla;
 787     i->fFunctions.fDeleteTextures = glDeleteTextures_mozilla;
 788     i->fFunctions.fDepthMask = glDepthMask_mozilla;
 789     i->fFunctions.fDisable = glDisable_mozilla;
 790     i->fFunctions.fDisableVertexAttribArray = glDisableVertexAttribArray_mozilla;
 791     i->fFunctions.fDrawArrays = glDrawArrays_mozilla;
 792     i->fFunctions.fDrawElements = glDrawElements_mozilla;
 793     i->fFunctions.fEnable = glEnable_mozilla;
 794     i->fFunctions.fEnableVertexAttribArray = glEnableVertexAttribArray_mozilla;
 795     i->fFunctions.fFinish = glFinish_mozilla;
 796     i->fFunctions.fFlush = glFlush_mozilla;
 797     i->fFunctions.fFramebufferRenderbuffer = glFramebufferRenderbuffer_mozilla;
 798     i->fFunctions.fFramebufferTexture2D = glFramebufferTexture2D_mozilla;
 799     i->fFunctions.fFrontFace = glFrontFace_mozilla;
 800     i->fFunctions.fGenBuffers = glGenBuffers_mozilla;
 801     i->fFunctions.fGenFramebuffers = glGenFramebuffers_mozilla;
 802     i->fFunctions.fGenRenderbuffers = glGenRenderbuffers_mozilla;
 803     i->fFunctions.fGetFramebufferAttachmentParameteriv = glGetFramebufferAttachmentParameteriv_mozilla;
 804     i->fFunctions.fGenTextures = glGenTextures_mozilla;
 805     i->fFunctions.fGenerateMipmap = glGenerateMipmap_mozilla;
 806     i->fFunctions.fGetBufferParameteriv = glGetBufferParameteriv_mozilla;
 807     i->fFunctions.fGetError = glGetError_mozilla;
 808     i->fFunctions.fGetIntegerv = glGetIntegerv_mozilla;
 809     i->fFunctions.fGetProgramInfoLog = glGetProgramInfoLog_mozilla;
 810     i->fFunctions.fGetProgramiv = glGetProgramiv_mozilla;
 811     i->fFunctions.fGetRenderbufferParameteriv = glGetRenderbufferParameteriv_mozilla;
 812     i->fFunctions.fGetShaderInfoLog = glGetShaderInfoLog_mozilla;
 813     i->fFunctions.fGetShaderiv = glGetShaderiv_mozilla;
 814     i->fFunctions.fGetString = glGetString_mozilla;
 815     i->fFunctions.fGetUniformLocation = glGetUniformLocation_mozilla;
 816     i->fFunctions.fLineWidth = glLineWidth_mozilla;
 817     i->fFunctions.fLinkProgram = glLinkProgram_mozilla;
 818     i->fFunctions.fPixelStorei = glPixelStorei_mozilla;
 819     i->fFunctions.fReadPixels = glReadPixels_mozilla;
 820     i->fFunctions.fRenderbufferStorage = glRenderbufferStorage_mozilla;
 821     i->fFunctions.fScissor = glScissor_mozilla;
 822     i->fFunctions.fShaderSource = glShaderSource_mozilla;
 823     i->fFunctions.fStencilFunc = glStencilFunc_mozilla;
 824     i->fFunctions.fStencilMask = glStencilMask_mozilla;
 825     i->fFunctions.fStencilOp = glStencilOp_mozilla;
 826     i->fFunctions.fTexImage2D = glTexImage2D_mozilla;
 827     i->fFunctions.fTexParameteri = glTexParameteri_mozilla;
 828     i->fFunctions.fTexParameteriv = glTexParameteriv_mozilla;
 829     i->fFunctions.fTexSubImage2D = glTexSubImage2D_mozilla;
 830     i->fFunctions.fUniform1f = glUniform1f_mozilla;
 831     i->fFunctions.fUniform1i = glUniform1i_mozilla;
 832     i->fFunctions.fUniform1fv = glUniform1fv_mozilla;
 833     i->fFunctions.fUniform1iv = glUniform1iv_mozilla;
 834     i->fFunctions.fUniform2f = glUniform2f_mozilla;
 835     i->fFunctions.fUniform2i = glUniform2i_mozilla;
 836     i->fFunctions.fUniform2fv = glUniform2fv_mozilla;
 837     i->fFunctions.fUniform2iv = glUniform2iv_mozilla;
 838     i->fFunctions.fUniform3f = glUniform3f_mozilla;
 839     i->fFunctions.fUniform3i = glUniform3i_mozilla;
 840     i->fFunctions.fUniform3fv = glUniform3fv_mozilla;
 841     i->fFunctions.fUniform3iv = glUniform3iv_mozilla;
 842     i->fFunctions.fUniform4f = glUniform4f_mozilla;
 843     i->fFunctions.fUniform4i = glUniform4i_mozilla;
 844     i->fFunctions.fUniform4fv = glUniform4fv_mozilla;
 845     i->fFunctions.fUniform4iv = glUniform4iv_mozilla;
 846     i->fFunctions.fUniformMatrix2fv = glUniformMatrix2fv_mozilla;
 847     i->fFunctions.fUniformMatrix3fv = glUniformMatrix3fv_mozilla;
 848     i->fFunctions.fUniformMatrix4fv = glUniformMatrix4fv_mozilla;
 849     i->fFunctions.fUseProgram = glUseProgram_mozilla;
 850     i->fFunctions.fVertexAttrib4fv = glVertexAttrib4fv_mozilla;
 851     i->fFunctions.fVertexAttribPointer = glVertexAttribPointer_mozilla;
 852     i->fFunctions.fViewport = glViewport_mozilla;
 853
 854     // Required for either desktop OpenGL 2.0 or OpenGL ES 2.0
 855     i->fFunctions.fStencilFuncSeparate = glStencilFuncSeparate_mozilla;
 856     i->fFunctions.fStencilMaskSeparate = glStencilMaskSeparate_mozilla;
 857     i->fFunctions.fStencilOpSeparate = glStencilOpSeparate_mozilla;
 858
 859     // GLContext supports glMapBuffer
 860     i->fFunctions.fMapBuffer = glMapBuffer_mozilla;
 861     i->fFunctions.fUnmapBuffer = glUnmapBuffer_mozilla;
 862
 863     // GLContext supports glRenderbufferStorageMultisample/glBlitFramebuffer
 864     i->fFunctions.fRenderbufferStorageMultisample = glRenderbufferStorageMultisample_mozilla;
 865     i->fFunctions.fBlitFramebuffer = glBlitFramebuffer_mozilla;
 866
 867     // GLContext supports glCompressedTexImage2D
 868     i->fFunctions.fCompressedTexImage2D = glCompressedTexImage2D_mozilla;
 869
 870     // GL_OES_vertex_array_object
 871     i->fFunctions.fBindVertexArray = glBindVertexArray_mozilla;
 872     i->fFunctions.fDeleteVertexArrays = glDeleteVertexArrays_mozilla;
 873     i->fFunctions.fGenVertexArrays = glGenVertexArrays_mozilla;
 874
 875     // Desktop GL
 876     i->fFunctions.fGetTexLevelParameteriv = glGetTexLevelParameteriv_mozilla;
 877     i->fFunctions.fDrawBuffer = glDrawBuffer_mozilla;
 878     i->fFunctions.fReadBuffer = glReadBuffer_mozilla;
 879
 880     // Desktop OpenGL > 1.5
 881     i->fFunctions.fGenQueries = glGenQueries_mozilla;
 882     i->fFunctions.fDeleteQueries = glDeleteQueries_mozilla;
 883     i->fFunctions.fBeginQuery = glBeginQuery_mozilla;
 884     i->fFunctions.fEndQuery = glEndQuery_mozilla;
 885     i->fFunctions.fGetQueryiv = glGetQueryiv_mozilla;
 886     i->fFunctions.fGetQueryObjectiv = glGetQueryObjectiv_mozilla;
 887     i->fFunctions.fGetQueryObjectuiv = glGetQueryObjectuiv_mozilla;
 888
 889     // Desktop OpenGL > 2.0
 890     i->fFunctions.fDrawBuffers = glDrawBuffers_mozilla;
 891
 892     return i;
 893 }
 894
 895 SkiaGLGlue::SkiaGLGlue(GLContext* context)
 896     : mGLContext(context)
 897 {
 898     mGrGLInterface.adopt(CreateGrGLInterfaceFromGLContext(mGLContext));
 899     mGrGLInterface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(this);
 900     mGrContext.adopt(GrContext::Create(kOpenGL_GrBackend, (GrBackendContext)mGrGLInterface.get()));
 901 }