src/third_party/skia/src/gpu/gl/GrGLAssembleInterface.cpp

   1
   2 /*
   3  * Copyright 2014 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9
  10 #include "GrGLAssembleInterface.h"
  11 #include "GrGLUtil.h"
  12
  13 #define GET_PROC(F) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
  14 #define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S)
  15 #define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
  16
  17 const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) {
  18     GET_PROC_LOCAL(GetString);
  19     if (NULL == GetString) {
  20         return NULL;
  21     }
  22
  23     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
  24     if (NULL == verStr) {
  25         return NULL;
  26     }
  27
  28     GrGLStandard standard = GrGLGetStandardInUseFromString(verStr);
  29
  30     if (kGLES_GrGLStandard == standard) {
  31         return GrGLAssembleGLESInterface(ctx, get);
  32     } else if (kGL_GrGLStandard == standard) {
  33         return GrGLAssembleGLInterface(ctx, get);
  34     }
  35     return NULL;
  36 }
  37
  38 const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
  39     GET_PROC_LOCAL(GetString);
  40     GET_PROC_LOCAL(GetStringi);
  41     GET_PROC_LOCAL(GetIntegerv);
  42
  43     // GetStringi may be NULL depending on the GL version.
  44     if (NULL == GetString || NULL == GetIntegerv) {
  45         return NULL;
  46     }
  47
  48     const char* versionString = (const char*) GetString(GR_GL_VERSION);
  49     GrGLVersion glVer = GrGLGetVersionFromString(versionString);
  50
  51     if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {
  52         // We must have array and element_array buffer objects.
  53         return NULL;
  54     }
  55
  56     GrGLExtensions extensions;
  57     if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv)) {
  58         return NULL;
  59     }
  60
  61     GrGLInterface* interface = SkNEW(GrGLInterface());
  62     GrGLInterface::Functions* functions = &interface->fFunctions;
  63
  64     GET_PROC(ActiveTexture);
  65     GET_PROC(AttachShader);
  66     GET_PROC(BindAttribLocation);
  67     GET_PROC(BindBuffer);
  68     if (glVer >= GR_GL_VER(3,0)) {
  69         GET_PROC(BindFragDataLocation);
  70     }
  71     GET_PROC(BeginQuery);
  72     GET_PROC(BindTexture);
  73     GET_PROC(BlendFunc);
  74
  75     if (glVer >= GR_GL_VER(1,4) ||
  76         extensions.has("GL_ARB_imaging") ||
  77         extensions.has("GL_EXT_blend_color")) {
  78         GET_PROC(BlendColor);
  79     }
  80
  81     GET_PROC(BufferData);
  82     GET_PROC(BufferSubData);
  83     GET_PROC(Clear);
  84     GET_PROC(ClearColor);
  85     GET_PROC(ClearStencil);
  86     GET_PROC(ColorMask);
  87     GET_PROC(CompileShader);
  88     GET_PROC(CompressedTexImage2D);
  89     GET_PROC(CompressedTexSubImage2D);
  90     GET_PROC(CopyTexSubImage2D);
  91     GET_PROC(CreateProgram);
  92     GET_PROC(CreateShader);
  93     GET_PROC(CullFace);
  94     GET_PROC(DeleteBuffers);
  95     GET_PROC(DeleteProgram);
  96     GET_PROC(DeleteQueries);
  97     GET_PROC(DeleteShader);
  98     GET_PROC(DeleteTextures);
  99     GET_PROC(DepthMask);
 100     GET_PROC(Disable);
 101     GET_PROC(DisableVertexAttribArray);
 102     GET_PROC(DrawArrays);
 103     GET_PROC(DrawBuffer);
 104     GET_PROC(DrawBuffers);
 105     GET_PROC(DrawElements);
 106     GET_PROC(Enable);
 107     GET_PROC(EnableVertexAttribArray);
 108     GET_PROC(EndQuery);
 109     GET_PROC(Finish);
 110     GET_PROC(Flush);
 111     GET_PROC(FrontFace);
 112     GET_PROC(GenBuffers);
 113     GET_PROC(GenerateMipmap);
 114     GET_PROC(GetBufferParameteriv);
 115     GET_PROC(GetError);
 116     GET_PROC(GetIntegerv);
 117     GET_PROC(GetQueryObjectiv);
 118     GET_PROC(GetQueryObjectuiv);
 119     if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) {
 120         GET_PROC(GetQueryObjecti64v);
 121         GET_PROC(GetQueryObjectui64v);
 122         GET_PROC(QueryCounter);
 123     } else if (extensions.has("GL_EXT_timer_query")) {
 124         GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
 125         GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
 126     }
 127     GET_PROC(GetQueryiv);
 128     GET_PROC(GetProgramInfoLog);
 129     GET_PROC(GetProgramiv);
 130     GET_PROC(GetShaderInfoLog);
 131     GET_PROC(GetShaderiv);
 132     GET_PROC(GetString);
 133     GET_PROC(GetStringi);
 134     GET_PROC(GetTexLevelParameteriv);
 135     GET_PROC(GenQueries);
 136     GET_PROC(GenTextures);
 137     GET_PROC(GetUniformLocation);
 138     GET_PROC(LineWidth);
 139     GET_PROC(LinkProgram);
 140     GET_PROC(MapBuffer);
 141     if (extensions.has("GL_EXT_direct_state_access")) {
 142         GET_PROC_SUFFIX(MatrixLoadf, EXT);
 143         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
 144     }
 145     GET_PROC(PixelStorei);
 146     GET_PROC(ReadBuffer);
 147     GET_PROC(ReadPixels);
 148     GET_PROC(Scissor);
 149     GET_PROC(ShaderSource);
 150     GET_PROC(StencilFunc);
 151     GET_PROC(StencilFuncSeparate);
 152     GET_PROC(StencilMask);
 153     GET_PROC(StencilMaskSeparate);
 154     GET_PROC(StencilOp);
 155     GET_PROC(StencilOpSeparate);
 156     GET_PROC(TexImage2D);
 157     GET_PROC(TexParameteri);
 158     GET_PROC(TexParameteriv);
 159     if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) {
 160         GET_PROC(TexStorage2D);
 161     } else if (extensions.has("GL_EXT_texture_storage")) {
 162         GET_PROC_SUFFIX(TexStorage2D, EXT);
 163     }
 164     GET_PROC(TexSubImage2D);
 165     GET_PROC(Uniform1f);
 166     GET_PROC(Uniform1i);
 167     GET_PROC(Uniform1fv);
 168     GET_PROC(Uniform1iv);
 169     GET_PROC(Uniform2f);
 170     GET_PROC(Uniform2i);
 171     GET_PROC(Uniform2fv);
 172     GET_PROC(Uniform2iv);
 173     GET_PROC(Uniform3f);
 174     GET_PROC(Uniform3i);
 175     GET_PROC(Uniform3fv);
 176     GET_PROC(Uniform3iv);
 177     GET_PROC(Uniform4f);
 178     GET_PROC(Uniform4i);
 179     GET_PROC(Uniform4fv);
 180     GET_PROC(Uniform4iv);
 181     GET_PROC(UniformMatrix2fv);
 182     GET_PROC(UniformMatrix3fv);
 183     GET_PROC(UniformMatrix4fv);
 184     GET_PROC(UnmapBuffer);
 185     GET_PROC(UseProgram);
 186     GET_PROC(VertexAttrib1f);
 187     GET_PROC(VertexAttrib2fv);
 188     GET_PROC(VertexAttrib3fv);
 189     GET_PROC(VertexAttrib4fv);
 190     GET_PROC(VertexAttribPointer);
 191     GET_PROC(Viewport);
 192     GET_PROC(BindFragDataLocationIndexed);
 193
 194     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) {
 195         // no ARB suffix for GL_ARB_vertex_array_object
 196         GET_PROC(BindVertexArray);
 197         GET_PROC(GenVertexArrays);
 198         GET_PROC(DeleteVertexArrays);
 199     }
 200
 201     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_map_buffer_range")) {
 202         GET_PROC(MapBufferRange);
 203         GET_PROC(FlushMappedBufferRange);
 204     }
 205
 206     // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
 207     // GL_ARB_framebuffer_object doesn't use ARB suffix.)
 208     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) {
 209         GET_PROC(GenFramebuffers);
 210         GET_PROC(GetFramebufferAttachmentParameteriv);
 211         GET_PROC(GetRenderbufferParameteriv);
 212         GET_PROC(BindFramebuffer);
 213         GET_PROC(FramebufferTexture2D);
 214         GET_PROC(CheckFramebufferStatus);
 215         GET_PROC(DeleteFramebuffers);
 216         GET_PROC(RenderbufferStorage);
 217         GET_PROC(GenRenderbuffers);
 218         GET_PROC(DeleteRenderbuffers);
 219         GET_PROC(FramebufferRenderbuffer);
 220         GET_PROC(BindRenderbuffer);
 221         GET_PROC(RenderbufferStorageMultisample);
 222         GET_PROC(BlitFramebuffer);
 223     } else if (extensions.has("GL_EXT_framebuffer_object")) {
 224         GET_PROC_SUFFIX(GenFramebuffers, EXT);
 225         GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
 226         GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
 227         GET_PROC_SUFFIX(BindFramebuffer, EXT);
 228         GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
 229         GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
 230         GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
 231         GET_PROC_SUFFIX(RenderbufferStorage, EXT);
 232         GET_PROC_SUFFIX(GenRenderbuffers, EXT);
 233         GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
 234         GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
 235         GET_PROC_SUFFIX(BindRenderbuffer, EXT);
 236         if (extensions.has("GL_EXT_framebuffer_multisample")) {
 237             GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
 238         }
 239         if (extensions.has("GL_EXT_framebuffer_blit")) {
 240             GET_PROC_SUFFIX(BlitFramebuffer, EXT);
 241         }
 242     } else {
 243         // we must have FBOs
 244         delete interface;
 245         return NULL;
 246     }
 247
 248     if (extensions.has("GL_NV_path_rendering")) {
 249         GET_PROC_SUFFIX(PathCommands, NV);
 250         GET_PROC_SUFFIX(PathCoords, NV);
 251         GET_PROC_SUFFIX(PathParameteri, NV);
 252         GET_PROC_SUFFIX(PathParameterf, NV);
 253         GET_PROC_SUFFIX(GenPaths, NV);
 254         GET_PROC_SUFFIX(DeletePaths, NV);
 255         GET_PROC_SUFFIX(IsPath, NV);
 256         GET_PROC_SUFFIX(PathStencilFunc, NV);
 257         GET_PROC_SUFFIX(StencilFillPath, NV);
 258         GET_PROC_SUFFIX(StencilStrokePath, NV);
 259         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
 260         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
 261         GET_PROC_SUFFIX(PathTexGen, NV);
 262         GET_PROC_SUFFIX(CoverFillPath, NV);
 263         GET_PROC_SUFFIX(CoverStrokePath, NV);
 264         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
 265         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
 266         // NV_path_rendering v1.2 (These methods may not be present)
 267         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
 268         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
 269         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
 270         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
 271         // NV_path_rendering v1.3 (These methods may not be present)
 272         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
 273         GET_PROC_SUFFIX(PathMemoryGlyphIndexArray, NV);
 274     }
 275
 276     if (extensions.has("GL_EXT_debug_marker")) {
 277         GET_PROC_SUFFIX(InsertEventMarker, EXT);
 278         GET_PROC_SUFFIX(PushGroupMarker, EXT);
 279         GET_PROC_SUFFIX(PopGroupMarker, EXT);
 280     }
 281
 282     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) {
 283         GET_PROC(InvalidateBufferData);
 284         GET_PROC(InvalidateBufferSubData);
 285         GET_PROC(InvalidateFramebuffer);
 286         GET_PROC(InvalidateSubFramebuffer);
 287         GET_PROC(InvalidateTexImage);
 288         GET_PROC(InvalidateTexSubImage);
 289     }
 290
 291     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) {
 292         GET_PROC(GetProgramResourceLocation);
 293     }
 294
 295     interface->fStandard = kGL_GrGLStandard;
 296     interface->fExtensions.swap(&extensions);
 297
 298     return interface;
 299 }
 300
 301 const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
 302     GET_PROC_LOCAL(GetString);
 303     if (NULL == GetString) {
 304         return NULL;
 305     }
 306
 307     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
 308     GrGLVersion version = GrGLGetVersionFromString(verStr);
 309
 310     if (version < GR_GL_VER(2,0)) {
 311         return NULL;
 312     }
 313
 314     GET_PROC_LOCAL(GetIntegerv);
 315     GET_PROC_LOCAL(GetStringi);
 316     GrGLExtensions extensions;
 317     if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv)) {
 318         return NULL;
 319     }
 320
 321     GrGLInterface* interface = SkNEW(GrGLInterface);
 322     GrGLInterface::Functions* functions = &interface->fFunctions;
 323
 324     GET_PROC(ActiveTexture);
 325     GET_PROC(AttachShader);
 326     GET_PROC(BindAttribLocation);
 327     GET_PROC(BindBuffer);
 328     GET_PROC(BindTexture);
 329     GET_PROC_SUFFIX(BindVertexArray, OES);
 330     GET_PROC(BlendColor);
 331     GET_PROC(BlendFunc);
 332     GET_PROC(BufferData);
 333     GET_PROC(BufferSubData);
 334     GET_PROC(Clear);
 335     GET_PROC(ClearColor);
 336     GET_PROC(ClearStencil);
 337     GET_PROC(ColorMask);
 338     GET_PROC(CompileShader);
 339     GET_PROC(CompressedTexImage2D);
 340     GET_PROC(CompressedTexSubImage2D);
 341     GET_PROC(CopyTexSubImage2D);
 342     GET_PROC(CreateProgram);
 343     GET_PROC(CreateShader);
 344     GET_PROC(CullFace);
 345     GET_PROC(DeleteBuffers);
 346     GET_PROC(DeleteProgram);
 347     GET_PROC(DeleteShader);
 348     GET_PROC(DeleteTextures);
 349     GET_PROC_SUFFIX(DeleteVertexArrays, OES);
 350     GET_PROC(DepthMask);
 351     GET_PROC(Disable);
 352     GET_PROC(DisableVertexAttribArray);
 353     GET_PROC(DrawArrays);
 354     GET_PROC(DrawElements);
 355     GET_PROC(Enable);
 356     GET_PROC(EnableVertexAttribArray);
 357     GET_PROC(Finish);
 358     GET_PROC(Flush);
 359     GET_PROC(FrontFace);
 360     GET_PROC(GenBuffers);
 361     GET_PROC(GenerateMipmap);
 362     GET_PROC(GenTextures);
 363     GET_PROC_SUFFIX(GenVertexArrays, OES);
 364     GET_PROC(GetBufferParameteriv);
 365     GET_PROC(GetError);
 366     GET_PROC(GetIntegerv);
 367     GET_PROC(GetProgramInfoLog);
 368     GET_PROC(GetProgramiv);
 369     GET_PROC(GetShaderInfoLog);
 370     GET_PROC(GetShaderiv);
 371     GET_PROC(GetString);
 372     GET_PROC(GetStringi);
 373     GET_PROC(GetUniformLocation);
 374     GET_PROC(LineWidth);
 375     GET_PROC(LinkProgram);
 376     GET_PROC(PixelStorei);
 377     GET_PROC(ReadPixels);
 378     GET_PROC(Scissor);
 379     GET_PROC(ShaderSource);
 380     GET_PROC(StencilFunc);
 381     GET_PROC(StencilFuncSeparate);
 382     GET_PROC(StencilMask);
 383     GET_PROC(StencilMaskSeparate);
 384     GET_PROC(StencilOp);
 385     GET_PROC(StencilOpSeparate);
 386     GET_PROC(TexImage2D);
 387     GET_PROC(TexParameteri);
 388     GET_PROC(TexParameteriv);
 389     GET_PROC(TexSubImage2D);
 390
 391     if (version >= GR_GL_VER(3,0)) {
 392         GET_PROC(TexStorage2D);
 393     } else {
 394         GET_PROC_SUFFIX(TexStorage2D, EXT);
 395     }
 396
 397     GET_PROC_SUFFIX(DiscardFramebuffer, EXT);
 398     GET_PROC(Uniform1f);
 399     GET_PROC(Uniform1i);
 400     GET_PROC(Uniform1fv);
 401     GET_PROC(Uniform1iv);
 402     GET_PROC(Uniform2f);
 403     GET_PROC(Uniform2i);
 404     GET_PROC(Uniform2fv);
 405     GET_PROC(Uniform2iv);
 406     GET_PROC(Uniform3f);
 407     GET_PROC(Uniform3i);
 408     GET_PROC(Uniform3fv);
 409     GET_PROC(Uniform3iv);
 410     GET_PROC(Uniform4f);
 411     GET_PROC(Uniform4i);
 412     GET_PROC(Uniform4fv);
 413     GET_PROC(Uniform4iv);
 414     GET_PROC(UniformMatrix2fv);
 415     GET_PROC(UniformMatrix3fv);
 416     GET_PROC(UniformMatrix4fv);
 417     GET_PROC(UseProgram);
 418     GET_PROC(VertexAttrib1f);
 419     GET_PROC(VertexAttrib2fv);
 420     GET_PROC(VertexAttrib3fv);
 421     GET_PROC(VertexAttrib4fv);
 422     GET_PROC(VertexAttribPointer);
 423     GET_PROC(Viewport);
 424     GET_PROC(BindFramebuffer);
 425     GET_PROC(BindRenderbuffer);
 426     GET_PROC(CheckFramebufferStatus);
 427     GET_PROC(DeleteFramebuffers);
 428     GET_PROC(DeleteRenderbuffers);
 429     GET_PROC(FramebufferRenderbuffer);
 430     GET_PROC(FramebufferTexture2D);
 431
 432     if (version >= GR_GL_VER(3,0)) {
 433         GET_PROC(RenderbufferStorageMultisample);
 434         GET_PROC(BlitFramebuffer);
 435     }
 436
 437     if (extensions.has("GL_EXT_multisampled_render_to_texture")) {
 438         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, EXT);
 439         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleEXT");
 440     } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) {
 441         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, IMG);
 442         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleIMG");
 443     } else if (extensions.has("GL_APPLE_framebuffer_multisample")) {
 444         functions->fRenderbufferStorageMultisampleES2APPLE = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleAPPLE");
 445         GET_PROC_SUFFIX(ResolveMultisampleFramebuffer, APPLE);
 446     }
 447
 448     GET_PROC(GenFramebuffers);
 449     GET_PROC(GenRenderbuffers);
 450     GET_PROC(GetFramebufferAttachmentParameteriv);
 451     GET_PROC(GetRenderbufferParameteriv);
 452     GET_PROC(RenderbufferStorage);
 453
 454     GET_PROC_SUFFIX(MapBuffer, OES);
 455     GET_PROC_SUFFIX(UnmapBuffer, OES);
 456
 457     if (version >= GR_GL_VER(3,0)) {
 458         GET_PROC(MapBufferRange);
 459         GET_PROC(FlushMappedBufferRange);
 460     } else if (extensions.has("GL_EXT_map_buffer_range")) {
 461         GET_PROC_SUFFIX(MapBufferRange, EXT);
 462         GET_PROC_SUFFIX(FlushMappedBufferRange, EXT);
 463     }
 464
 465     if (extensions.has("GL_EXT_debug_marker")) {
 466         GET_PROC(InsertEventMarker);
 467         GET_PROC(PushGroupMarker);
 468         GET_PROC(PopGroupMarker);
 469         // The below check is here because a device has been found that has the extension string but
 470         // returns NULL from the eglGetProcAddress for the functions
 471         if (NULL == functions->fInsertEventMarker ||
 472             NULL == functions->fPushGroupMarker ||
 473             NULL == functions->fPopGroupMarker) {
 474             extensions.remove("GL_EXT_debug_marker");
 475         }
 476     }
 477
 478     GET_PROC(InvalidateFramebuffer);
 479     GET_PROC(InvalidateSubFramebuffer);
 480     GET_PROC(InvalidateBufferData);
 481     GET_PROC(InvalidateBufferSubData);
 482     GET_PROC(InvalidateTexImage);
 483     GET_PROC(InvalidateTexSubImage);
 484
 485     if (version >= GR_GL_VER(3,1)) {
 486         GET_PROC(GetProgramResourceLocation);
 487     }
 488
 489     if (extensions.has("GL_NV_path_rendering")) {
 490         GET_PROC_SUFFIX(MatrixLoadf, EXT);
 491         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
 492         GET_PROC_SUFFIX(PathCommands, NV);
 493         GET_PROC_SUFFIX(PathCoords, NV);
 494         GET_PROC_SUFFIX(PathParameteri, NV);
 495         GET_PROC_SUFFIX(PathParameterf, NV);
 496         GET_PROC_SUFFIX(GenPaths, NV);
 497         GET_PROC_SUFFIX(DeletePaths, NV);
 498         GET_PROC_SUFFIX(IsPath, NV);
 499         GET_PROC_SUFFIX(PathStencilFunc, NV);
 500         GET_PROC_SUFFIX(StencilFillPath, NV);
 501         GET_PROC_SUFFIX(StencilStrokePath, NV);
 502         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
 503         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
 504         GET_PROC_SUFFIX(CoverFillPath, NV);
 505         GET_PROC_SUFFIX(CoverStrokePath, NV);
 506         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
 507         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
 508         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
 509         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
 510         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
 511         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
 512         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
 513         GET_PROC_SUFFIX(PathMemoryGlyphIndexArray, NV);
 514     }
 515
 516     interface->fStandard = kGLES_GrGLStandard;
 517     interface->fExtensions.swap(&extensions);
 518
 519     return interface;
 520 }