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 #define GET_EGL_PROC_SUFFIX(F, S) functions->fEGL ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S)
18 
GrGLAssembleInterface(void * ctx,GrGLGetProc get)19 const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) {
20     GET_PROC_LOCAL(GetString);
21     if (nullptr == GetString) {
22         return nullptr;
23     }
24 
25     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
26     if (nullptr == verStr) {
27         return nullptr;
28     }
29 
30     GrGLStandard standard = GrGLGetStandardInUseFromString(verStr);
31 
32     if (kGLES_GrGLStandard == standard) {
33         return GrGLAssembleGLESInterface(ctx, get);
34     } else if (kGL_GrGLStandard == standard) {
35         return GrGLAssembleGLInterface(ctx, get);
36     }
37     return nullptr;
38 }
39 
get_egl_query_and_display(GrEGLQueryStringProc * queryString,GrEGLDisplay * display,void * ctx,GrGLGetProc get)40 static void get_egl_query_and_display(GrEGLQueryStringProc* queryString, GrEGLDisplay* display,
41                                       void* ctx, GrGLGetProc get) {
42     *queryString = (GrEGLQueryStringProc) get(ctx, "eglQueryString");
43     *display = GR_EGL_NO_DISPLAY;
44     if (*queryString) {
45         GrEGLGetCurrentDisplayProc getCurrentDisplay =
46             (GrEGLGetCurrentDisplayProc) get(ctx, "eglGetCurrentDisplay");
47         if (getCurrentDisplay) {
48             *display = getCurrentDisplay();
49         } else {
50             *queryString = nullptr;
51         }
52     }
53 }
54 
GrGLAssembleGLInterface(void * ctx,GrGLGetProc get)55 const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
56     GET_PROC_LOCAL(GetString);
57     GET_PROC_LOCAL(GetStringi);
58     GET_PROC_LOCAL(GetIntegerv);
59 
60     // GetStringi may be nullptr depending on the GL version.
61     if (nullptr == GetString || nullptr == GetIntegerv) {
62         return nullptr;
63     }
64 
65     const char* versionString = (const char*) GetString(GR_GL_VERSION);
66     GrGLVersion glVer = GrGLGetVersionFromString(versionString);
67 
68     if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {
69         // We must have array and element_array buffer objects.
70         return nullptr;
71     }
72 
73     GrEGLQueryStringProc queryString;
74     GrEGLDisplay display;
75     get_egl_query_and_display(&queryString, &display, ctx, get);
76     GrGLExtensions extensions;
77     if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
78                          display)) {
79         return nullptr;
80     }
81 
82     GrGLInterface* interface = new GrGLInterface();
83     GrGLInterface::Functions* functions = &interface->fFunctions;
84 
85     GET_PROC(ActiveTexture);
86     GET_PROC(AttachShader);
87     GET_PROC(BindAttribLocation);
88     GET_PROC(BindBuffer);
89     if (glVer >= GR_GL_VER(3,0)) {
90         GET_PROC(BindFragDataLocation);
91     }
92     GET_PROC(BeginQuery);
93     GET_PROC(BindTexture);
94 
95     if (extensions.has("GL_KHR_blend_equation_advanced")) {
96         GET_PROC_SUFFIX(BlendBarrier, KHR);
97     } else if (extensions.has("GL_NV_blend_equation_advanced")) {
98         GET_PROC_SUFFIX(BlendBarrier, NV);
99     }
100 
101     if (glVer >= GR_GL_VER(1,4) ||
102         extensions.has("GL_ARB_imaging")) {
103         GET_PROC(BlendColor);
104     } else if (extensions.has("GL_EXT_blend_color")) {
105         GET_PROC_SUFFIX(BlendColor, EXT);
106     }
107 
108     if (glVer >= GR_GL_VER(1,4) ||
109         extensions.has("GL_ARB_imaging")) {
110         GET_PROC(BlendEquation);
111     } else if (extensions.has("GL_EXT_blend_subtract")) {
112         GET_PROC_SUFFIX(BlendEquation, EXT);
113     }
114 
115     GET_PROC(BlendFunc);
116     GET_PROC(BufferData);
117     GET_PROC(BufferSubData);
118     GET_PROC(Clear);
119     GET_PROC(ClearColor);
120     GET_PROC(ClearStencil);
121     GET_PROC(ColorMask);
122     GET_PROC(CompileShader);
123     GET_PROC(CompressedTexImage2D);
124     GET_PROC(CompressedTexSubImage2D);
125     GET_PROC(CopyTexSubImage2D);
126     GET_PROC(CreateProgram);
127     GET_PROC(CreateShader);
128     GET_PROC(CullFace);
129     GET_PROC(DeleteBuffers);
130     GET_PROC(DeleteProgram);
131     GET_PROC(DeleteQueries);
132     GET_PROC(DeleteShader);
133     GET_PROC(DeleteTextures);
134     GET_PROC(DepthMask);
135     GET_PROC(Disable);
136     GET_PROC(DisableVertexAttribArray);
137     GET_PROC(DrawArrays);
138     GET_PROC(DrawBuffer);
139     GET_PROC(DrawBuffers);
140     GET_PROC(DrawElements);
141 
142     if (glVer >= GR_GL_VER(3,1) || extensions.has("GL_ARB_draw_instanced") ||
143         extensions.has("GL_EXT_draw_instanced")) {
144         GET_PROC(DrawArraysInstanced);
145         GET_PROC(DrawElementsInstanced);
146     }
147 
148     if (glVer >= GR_GL_VER(4,0)) {
149         // We don't use ARB_draw_indirect because it does not support a base instance.
150         GET_PROC(DrawArraysIndirect);
151         GET_PROC(DrawElementsIndirect);
152     }
153 
154     GET_PROC(Enable);
155     GET_PROC(EnableVertexAttribArray);
156     GET_PROC(EndQuery);
157     GET_PROC(Finish);
158     GET_PROC(Flush);
159     GET_PROC(FrontFace);
160     GET_PROC(GenBuffers);
161     GET_PROC(GenerateMipmap);
162     GET_PROC(GetBufferParameteriv);
163     GET_PROC(GetError);
164     GET_PROC(GetIntegerv);
165     GET_PROC(GetQueryObjectiv);
166     GET_PROC(GetQueryObjectuiv);
167     if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) {
168         GET_PROC(GetQueryObjecti64v);
169         GET_PROC(GetQueryObjectui64v);
170         GET_PROC(QueryCounter);
171     } else if (extensions.has("GL_EXT_timer_query")) {
172         GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
173         GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
174     }
175     GET_PROC(GetQueryiv);
176     GET_PROC(GetProgramInfoLog);
177     GET_PROC(GetProgramiv);
178     GET_PROC(GetShaderInfoLog);
179     GET_PROC(GetShaderiv);
180     GET_PROC(GetString);
181     GET_PROC(GetStringi);
182     GET_PROC(GetShaderPrecisionFormat);
183     GET_PROC(GetTexLevelParameteriv);
184     GET_PROC(GenQueries);
185     GET_PROC(GenTextures);
186     GET_PROC(GetUniformLocation);
187     GET_PROC(IsTexture);
188     GET_PROC(LineWidth);
189     GET_PROC(LinkProgram);
190     GET_PROC(MapBuffer);
191     GET_PROC(PixelStorei);
192     if (extensions.has("GL_EXT_raster_multisample")) {
193         GET_PROC_SUFFIX(RasterSamples, EXT);
194     }
195     GET_PROC(ReadBuffer);
196     GET_PROC(ReadPixels);
197     GET_PROC(Scissor);
198     GET_PROC(ShaderSource);
199     GET_PROC(StencilFunc);
200     GET_PROC(StencilFuncSeparate);
201     GET_PROC(StencilMask);
202     GET_PROC(StencilMaskSeparate);
203     GET_PROC(StencilOp);
204     GET_PROC(StencilOpSeparate);
205     GET_PROC(TexImage2D);
206     GET_PROC(TexParameteri);
207     GET_PROC(TexParameteriv);
208     if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) {
209         GET_PROC(TexStorage2D);
210     } else if (extensions.has("GL_EXT_texture_storage")) {
211         GET_PROC_SUFFIX(TexStorage2D, EXT);
212     }
213     GET_PROC(TexSubImage2D);
214     if (glVer >= GR_GL_VER(4,5) || extensions.has("GL_ARB_texture_barrier")) {
215         GET_PROC(TextureBarrier);
216     } else if (extensions.has("GL_NV_texture_barrier")) {
217         GET_PROC_SUFFIX(TextureBarrier, NV);
218     }
219     GET_PROC(Uniform1f);
220     GET_PROC(Uniform1i);
221     GET_PROC(Uniform1fv);
222     GET_PROC(Uniform1iv);
223     GET_PROC(Uniform2f);
224     GET_PROC(Uniform2i);
225     GET_PROC(Uniform2fv);
226     GET_PROC(Uniform2iv);
227     GET_PROC(Uniform3f);
228     GET_PROC(Uniform3i);
229     GET_PROC(Uniform3fv);
230     GET_PROC(Uniform3iv);
231     GET_PROC(Uniform4f);
232     GET_PROC(Uniform4i);
233     GET_PROC(Uniform4fv);
234     GET_PROC(Uniform4iv);
235     GET_PROC(UniformMatrix2fv);
236     GET_PROC(UniformMatrix3fv);
237     GET_PROC(UniformMatrix4fv);
238     GET_PROC(UnmapBuffer);
239     GET_PROC(UseProgram);
240     GET_PROC(VertexAttrib1f);
241     GET_PROC(VertexAttrib2fv);
242     GET_PROC(VertexAttrib3fv);
243     GET_PROC(VertexAttrib4fv);
244 
245     if (glVer >= GR_GL_VER(3,2) || extensions.has("GL_ARB_instanced_arrays")) {
246         GET_PROC(VertexAttribDivisor);
247     }
248 
249     if (glVer >= GR_GL_VER(3,0)) {
250         GET_PROC(VertexAttribIPointer);
251     }
252 
253     GET_PROC(VertexAttribPointer);
254     GET_PROC(Viewport);
255     GET_PROC(BindFragDataLocationIndexed);
256 
257     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) {
258         // no ARB suffix for GL_ARB_vertex_array_object
259         GET_PROC(BindVertexArray);
260         GET_PROC(GenVertexArrays);
261         GET_PROC(DeleteVertexArrays);
262     } else if (extensions.has("GL_APPLE_vertex_array_object")) {
263         GET_PROC_SUFFIX(BindVertexArray, APPLE);
264         GET_PROC_SUFFIX(GenVertexArrays, APPLE);
265         GET_PROC_SUFFIX(DeleteVertexArrays, APPLE);
266     }
267 
268     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_map_buffer_range")) {
269         GET_PROC(MapBufferRange);
270         GET_PROC(FlushMappedBufferRange);
271     }
272 
273     // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
274     // GL_ARB_framebuffer_object doesn't use ARB suffix.)
275     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) {
276         GET_PROC(GenFramebuffers);
277         GET_PROC(GetFramebufferAttachmentParameteriv);
278         GET_PROC(GetRenderbufferParameteriv);
279         GET_PROC(BindFramebuffer);
280         GET_PROC(FramebufferTexture2D);
281         GET_PROC(CheckFramebufferStatus);
282         GET_PROC(DeleteFramebuffers);
283         GET_PROC(RenderbufferStorage);
284         GET_PROC(GenRenderbuffers);
285         GET_PROC(DeleteRenderbuffers);
286         GET_PROC(FramebufferRenderbuffer);
287         GET_PROC(BindRenderbuffer);
288         GET_PROC(RenderbufferStorageMultisample);
289         GET_PROC(BlitFramebuffer);
290     } else if (extensions.has("GL_EXT_framebuffer_object")) {
291         GET_PROC_SUFFIX(GenFramebuffers, EXT);
292         GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
293         GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
294         GET_PROC_SUFFIX(BindFramebuffer, EXT);
295         GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
296         GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
297         GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
298         GET_PROC_SUFFIX(RenderbufferStorage, EXT);
299         GET_PROC_SUFFIX(GenRenderbuffers, EXT);
300         GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
301         GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
302         GET_PROC_SUFFIX(BindRenderbuffer, EXT);
303         if (extensions.has("GL_EXT_framebuffer_multisample")) {
304             GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
305         }
306         if (extensions.has("GL_EXT_framebuffer_blit")) {
307             GET_PROC_SUFFIX(BlitFramebuffer, EXT);
308         }
309     } else {
310         // we must have FBOs
311         delete interface;
312         return nullptr;
313     }
314 
315     if (extensions.has("GL_NV_path_rendering")) {
316         GET_PROC_SUFFIX(MatrixLoadf, EXT);
317         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
318         GET_PROC_SUFFIX(PathCommands, NV);
319         GET_PROC_SUFFIX(PathParameteri, NV);
320         GET_PROC_SUFFIX(PathParameterf, NV);
321         GET_PROC_SUFFIX(GenPaths, NV);
322         GET_PROC_SUFFIX(DeletePaths, NV);
323         GET_PROC_SUFFIX(IsPath, NV);
324         GET_PROC_SUFFIX(PathStencilFunc, NV);
325         GET_PROC_SUFFIX(StencilFillPath, NV);
326         GET_PROC_SUFFIX(StencilStrokePath, NV);
327         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
328         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
329         GET_PROC_SUFFIX(CoverFillPath, NV);
330         GET_PROC_SUFFIX(CoverStrokePath, NV);
331         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
332         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
333         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
334         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
335         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
336         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
337         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
338     }
339 
340     if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
341         GET_PROC_SUFFIX(CoverageModulation, NV);
342     }
343 
344     if (extensions.has("GL_EXT_debug_marker")) {
345         GET_PROC_SUFFIX(InsertEventMarker, EXT);
346         GET_PROC_SUFFIX(PushGroupMarker, EXT);
347         GET_PROC_SUFFIX(PopGroupMarker, EXT);
348     }
349 
350     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) {
351         GET_PROC(InvalidateBufferData);
352         GET_PROC(InvalidateBufferSubData);
353         GET_PROC(InvalidateFramebuffer);
354         GET_PROC(InvalidateSubFramebuffer);
355         GET_PROC(InvalidateTexImage);
356         GET_PROC(InvalidateTexSubImage);
357     }
358 
359     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) {
360         GET_PROC(GetProgramResourceLocation);
361     }
362 
363     if (glVer >= GR_GL_VER(4,3)) {
364         // We don't use ARB_multi_draw_indirect because it does not support GL_DRAW_INDIRECT_BUFFER.
365         GET_PROC(MultiDrawArraysIndirect);
366         GET_PROC(MultiDrawElementsIndirect);
367     }
368 
369     if (extensions.has("GL_NV_bindless_texture")) {
370         GET_PROC_SUFFIX(GetTextureHandle, NV);
371         GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
372         GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
373         GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
374         GET_PROC_SUFFIX(GetImageHandle, NV);
375         GET_PROC_SUFFIX(MakeImageHandleResident, NV);
376         GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
377         GET_PROC_SUFFIX(IsTextureHandleResident, NV);
378         GET_PROC_SUFFIX(IsImageHandleResident, NV);
379         GET_PROC_SUFFIX(UniformHandleui64, NV);
380         GET_PROC_SUFFIX(UniformHandleui64v, NV);
381         GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
382         GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
383     }
384 
385     if (extensions.has("GL_EXT_direct_state_access")) {
386         GET_PROC_SUFFIX(TextureParameteri, EXT);
387         GET_PROC_SUFFIX(TextureParameteriv, EXT);
388         GET_PROC_SUFFIX(TextureParameterf, EXT);
389         GET_PROC_SUFFIX(TextureParameterfv, EXT);
390         GET_PROC_SUFFIX(TextureImage1D, EXT);
391         GET_PROC_SUFFIX(TextureImage2D, EXT);
392         GET_PROC_SUFFIX(TextureSubImage1D, EXT);
393         GET_PROC_SUFFIX(TextureSubImage2D, EXT);
394         GET_PROC_SUFFIX(CopyTextureImage1D, EXT);
395         GET_PROC_SUFFIX(CopyTextureImage2D, EXT);
396         GET_PROC_SUFFIX(CopyTextureSubImage1D, EXT);
397         GET_PROC_SUFFIX(CopyTextureSubImage2D, EXT);
398         GET_PROC_SUFFIX(GetTextureImage, EXT);
399         GET_PROC_SUFFIX(GetTextureParameterfv, EXT);
400         GET_PROC_SUFFIX(GetTextureParameteriv, EXT);
401         GET_PROC_SUFFIX(GetTextureLevelParameterfv, EXT);
402         GET_PROC_SUFFIX(GetTextureLevelParameteriv, EXT);
403         if (glVer >= GR_GL_VER(1,2)) {
404             GET_PROC_SUFFIX(TextureImage3D, EXT);
405             GET_PROC_SUFFIX(TextureSubImage3D, EXT);
406             GET_PROC_SUFFIX(CopyTextureSubImage3D, EXT);
407             GET_PROC_SUFFIX(CompressedTextureImage3D, EXT);
408             GET_PROC_SUFFIX(CompressedTextureImage2D, EXT);
409             GET_PROC_SUFFIX(CompressedTextureImage1D, EXT);
410             GET_PROC_SUFFIX(CompressedTextureSubImage3D, EXT);
411             GET_PROC_SUFFIX(CompressedTextureSubImage2D, EXT);
412             GET_PROC_SUFFIX(CompressedTextureSubImage1D, EXT);
413             GET_PROC_SUFFIX(GetCompressedTextureImage, EXT);
414         }
415         if (glVer >= GR_GL_VER(1,5)) {
416             GET_PROC_SUFFIX(NamedBufferData, EXT);
417             GET_PROC_SUFFIX(NamedBufferSubData, EXT);
418             GET_PROC_SUFFIX(MapNamedBuffer, EXT);
419             GET_PROC_SUFFIX(UnmapNamedBuffer, EXT);
420             GET_PROC_SUFFIX(GetNamedBufferParameteriv, EXT);
421             GET_PROC_SUFFIX(GetNamedBufferPointerv, EXT);
422             GET_PROC_SUFFIX(GetNamedBufferSubData, EXT);
423         }
424         if (glVer >= GR_GL_VER(2,0)) {
425             GET_PROC_SUFFIX(ProgramUniform1f, EXT);
426             GET_PROC_SUFFIX(ProgramUniform2f, EXT);
427             GET_PROC_SUFFIX(ProgramUniform3f, EXT);
428             GET_PROC_SUFFIX(ProgramUniform4f, EXT);
429             GET_PROC_SUFFIX(ProgramUniform1i, EXT);
430             GET_PROC_SUFFIX(ProgramUniform2i, EXT);
431             GET_PROC_SUFFIX(ProgramUniform3i, EXT);
432             GET_PROC_SUFFIX(ProgramUniform4i, EXT);
433             GET_PROC_SUFFIX(ProgramUniform1fv, EXT);
434             GET_PROC_SUFFIX(ProgramUniform2fv, EXT);
435             GET_PROC_SUFFIX(ProgramUniform3fv, EXT);
436             GET_PROC_SUFFIX(ProgramUniform4fv, EXT);
437             GET_PROC_SUFFIX(ProgramUniform1iv, EXT);
438             GET_PROC_SUFFIX(ProgramUniform2iv, EXT);
439             GET_PROC_SUFFIX(ProgramUniform3iv, EXT);
440             GET_PROC_SUFFIX(ProgramUniform4iv, EXT);
441             GET_PROC_SUFFIX(ProgramUniformMatrix2fv, EXT);
442             GET_PROC_SUFFIX(ProgramUniformMatrix3fv, EXT);
443             GET_PROC_SUFFIX(ProgramUniformMatrix4fv, EXT);
444         }
445         if (glVer >= GR_GL_VER(2,1)) {
446             GET_PROC_SUFFIX(ProgramUniformMatrix2x3fv, EXT);
447             GET_PROC_SUFFIX(ProgramUniformMatrix3x2fv, EXT);
448             GET_PROC_SUFFIX(ProgramUniformMatrix2x4fv, EXT);
449             GET_PROC_SUFFIX(ProgramUniformMatrix4x2fv, EXT);
450             GET_PROC_SUFFIX(ProgramUniformMatrix3x4fv, EXT);
451             GET_PROC_SUFFIX(ProgramUniformMatrix4x3fv, EXT);
452         }
453         if (glVer >= GR_GL_VER(3,0)) {
454             GET_PROC_SUFFIX(NamedRenderbufferStorage, EXT);
455             GET_PROC_SUFFIX(GetNamedRenderbufferParameteriv, EXT);
456             GET_PROC_SUFFIX(NamedRenderbufferStorageMultisample, EXT);
457             GET_PROC_SUFFIX(CheckNamedFramebufferStatus, EXT);
458             GET_PROC_SUFFIX(NamedFramebufferTexture1D, EXT);
459             GET_PROC_SUFFIX(NamedFramebufferTexture2D, EXT);
460             GET_PROC_SUFFIX(NamedFramebufferTexture3D, EXT);
461             GET_PROC_SUFFIX(NamedFramebufferRenderbuffer, EXT);
462             GET_PROC_SUFFIX(GetNamedFramebufferAttachmentParameteriv, EXT);
463             GET_PROC_SUFFIX(GenerateTextureMipmap, EXT);
464             GET_PROC_SUFFIX(FramebufferDrawBuffer, EXT);
465             GET_PROC_SUFFIX(FramebufferDrawBuffers, EXT);
466             GET_PROC_SUFFIX(FramebufferReadBuffer, EXT);
467             GET_PROC_SUFFIX(GetFramebufferParameteriv, EXT);
468             GET_PROC_SUFFIX(NamedCopyBufferSubData, EXT);
469             GET_PROC_SUFFIX(VertexArrayVertexOffset, EXT);
470             GET_PROC_SUFFIX(VertexArrayColorOffset, EXT);
471             GET_PROC_SUFFIX(VertexArrayEdgeFlagOffset, EXT);
472             GET_PROC_SUFFIX(VertexArrayIndexOffset, EXT);
473             GET_PROC_SUFFIX(VertexArrayNormalOffset, EXT);
474             GET_PROC_SUFFIX(VertexArrayTexCoordOffset, EXT);
475             GET_PROC_SUFFIX(VertexArrayMultiTexCoordOffset, EXT);
476             GET_PROC_SUFFIX(VertexArrayFogCoordOffset, EXT);
477             GET_PROC_SUFFIX(VertexArraySecondaryColorOffset, EXT);
478             GET_PROC_SUFFIX(VertexArrayVertexAttribOffset, EXT);
479             GET_PROC_SUFFIX(VertexArrayVertexAttribIOffset, EXT);
480             GET_PROC_SUFFIX(EnableVertexArray, EXT);
481             GET_PROC_SUFFIX(DisableVertexArray, EXT);
482             GET_PROC_SUFFIX(EnableVertexArrayAttrib, EXT);
483             GET_PROC_SUFFIX(DisableVertexArrayAttrib, EXT);
484             GET_PROC_SUFFIX(GetVertexArrayIntegerv, EXT);
485             GET_PROC_SUFFIX(GetVertexArrayPointerv, EXT);
486             GET_PROC_SUFFIX(GetVertexArrayIntegeri_v, EXT);
487             GET_PROC_SUFFIX(GetVertexArrayPointeri_v, EXT);
488             GET_PROC_SUFFIX(MapNamedBufferRange, EXT);
489             GET_PROC_SUFFIX(FlushMappedNamedBufferRange, EXT);
490         }
491     }
492 
493     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_KHR_debug")) {
494         // KHR_debug defines these methods to have no suffix in an OpenGL (not ES) context.
495         GET_PROC(DebugMessageControl);
496         GET_PROC(DebugMessageInsert);
497         GET_PROC(DebugMessageCallback);
498         GET_PROC(GetDebugMessageLog);
499         GET_PROC(PushDebugGroup);
500         GET_PROC(PopDebugGroup);
501         GET_PROC(ObjectLabel);
502     }
503 
504     if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
505         GET_EGL_PROC_SUFFIX(CreateImage, KHR);
506         GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
507     }
508 
509     interface->fStandard = kGL_GrGLStandard;
510     interface->fExtensions.swap(&extensions);
511 
512     return interface;
513 }
514 
GrGLAssembleGLESInterface(void * ctx,GrGLGetProc get)515 const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
516     GET_PROC_LOCAL(GetString);
517     if (nullptr == GetString) {
518         return nullptr;
519     }
520 
521     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
522     GrGLVersion version = GrGLGetVersionFromString(verStr);
523 
524     if (version < GR_GL_VER(2,0)) {
525         return nullptr;
526     }
527 
528     GET_PROC_LOCAL(GetIntegerv);
529     GET_PROC_LOCAL(GetStringi);
530     GrEGLQueryStringProc queryString;
531     GrEGLDisplay display;
532     get_egl_query_and_display(&queryString, &display, ctx, get);
533     GrGLExtensions extensions;
534     if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
535                          display)) {
536         return nullptr;
537     }
538 
539     GrGLInterface* interface = new GrGLInterface;
540     GrGLInterface::Functions* functions = &interface->fFunctions;
541 
542     GET_PROC(ActiveTexture);
543     GET_PROC(AttachShader);
544     GET_PROC(BindAttribLocation);
545     GET_PROC(BindBuffer);
546     GET_PROC(BindTexture);
547     GET_PROC_SUFFIX(BindVertexArray, OES);
548 
549     if (version >= GR_GL_VER(3,0) && extensions.has("GL_EXT_blend_func_extended")) {
550         GET_PROC_SUFFIX(BindFragDataLocation, EXT);
551         GET_PROC_SUFFIX(BindFragDataLocationIndexed, EXT);
552     }
553 
554     if (extensions.has("GL_KHR_blend_equation_advanced")) {
555         GET_PROC_SUFFIX(BlendBarrier, KHR);
556     } else if (extensions.has("GL_NV_blend_equation_advanced")) {
557         GET_PROC_SUFFIX(BlendBarrier, NV);
558     }
559 
560     GET_PROC(BlendColor);
561     GET_PROC(BlendEquation);
562     GET_PROC(BlendFunc);
563     GET_PROC(BufferData);
564     GET_PROC(BufferSubData);
565     GET_PROC(Clear);
566     GET_PROC(ClearColor);
567     GET_PROC(ClearStencil);
568     GET_PROC(ColorMask);
569     GET_PROC(CompileShader);
570     GET_PROC(CompressedTexImage2D);
571     GET_PROC(CompressedTexSubImage2D);
572     GET_PROC(CopyTexSubImage2D);
573     GET_PROC(CreateProgram);
574     GET_PROC(CreateShader);
575     GET_PROC(CullFace);
576     GET_PROC(DeleteBuffers);
577     GET_PROC(DeleteProgram);
578     GET_PROC(DeleteShader);
579     GET_PROC(DeleteTextures);
580     GET_PROC_SUFFIX(DeleteVertexArrays, OES);
581     GET_PROC(DepthMask);
582     GET_PROC(Disable);
583     GET_PROC(DisableVertexAttribArray);
584     GET_PROC(DrawArrays);
585 
586     if (version >= GR_GL_VER(3,0)) {
587         GET_PROC(DrawArraysInstanced);
588         GET_PROC(DrawElementsInstanced);
589     } else if (extensions.has("GL_EXT_draw_instanced")) {
590         GET_PROC_SUFFIX(DrawArraysInstanced, EXT);
591         GET_PROC_SUFFIX(DrawElementsInstanced, EXT);
592     }
593 
594     if (version >= GR_GL_VER(3,1)) {
595         GET_PROC(DrawArraysIndirect);
596         GET_PROC(DrawElementsIndirect);
597     }
598 
599     GET_PROC(DrawElements);
600     GET_PROC(Enable);
601     GET_PROC(EnableVertexAttribArray);
602     GET_PROC(Finish);
603     GET_PROC(Flush);
604     GET_PROC(FrontFace);
605     GET_PROC(GenBuffers);
606     GET_PROC(GenerateMipmap);
607     GET_PROC(GenTextures);
608     GET_PROC_SUFFIX(GenVertexArrays, OES);
609     GET_PROC(GetBufferParameteriv);
610     GET_PROC(GetError);
611     GET_PROC(GetIntegerv);
612     GET_PROC(GetProgramInfoLog);
613     GET_PROC(GetProgramiv);
614     GET_PROC(GetShaderInfoLog);
615     GET_PROC(GetShaderPrecisionFormat);
616     GET_PROC(GetShaderiv);
617     GET_PROC(GetString);
618     GET_PROC(GetStringi);
619     GET_PROC(GetUniformLocation);
620     GET_PROC(IsTexture);
621     GET_PROC(LineWidth);
622     GET_PROC(LinkProgram);
623     GET_PROC(PixelStorei);
624 
625     if (extensions.has("GL_EXT_raster_multisample")) {
626         GET_PROC_SUFFIX(RasterSamples, EXT);
627     }
628 
629     GET_PROC(ReadPixels);
630     GET_PROC(Scissor);
631     GET_PROC(ShaderSource);
632     GET_PROC(StencilFunc);
633     GET_PROC(StencilFuncSeparate);
634     GET_PROC(StencilMask);
635     GET_PROC(StencilMaskSeparate);
636     GET_PROC(StencilOp);
637     GET_PROC(StencilOpSeparate);
638     GET_PROC(TexImage2D);
639     GET_PROC(TexParameteri);
640     GET_PROC(TexParameteriv);
641     GET_PROC(TexSubImage2D);
642 
643     if (version >= GR_GL_VER(3,0)) {
644         GET_PROC(TexStorage2D);
645     } else {
646         GET_PROC_SUFFIX(TexStorage2D, EXT);
647     }
648 
649     if (extensions.has("GL_NV_texture_barrier")) {
650         GET_PROC_SUFFIX(TextureBarrier, NV);
651     }
652 
653     GET_PROC_SUFFIX(DiscardFramebuffer, EXT);
654     GET_PROC(Uniform1f);
655     GET_PROC(Uniform1i);
656     GET_PROC(Uniform1fv);
657     GET_PROC(Uniform1iv);
658     GET_PROC(Uniform2f);
659     GET_PROC(Uniform2i);
660     GET_PROC(Uniform2fv);
661     GET_PROC(Uniform2iv);
662     GET_PROC(Uniform3f);
663     GET_PROC(Uniform3i);
664     GET_PROC(Uniform3fv);
665     GET_PROC(Uniform3iv);
666     GET_PROC(Uniform4f);
667     GET_PROC(Uniform4i);
668     GET_PROC(Uniform4fv);
669     GET_PROC(Uniform4iv);
670     GET_PROC(UniformMatrix2fv);
671     GET_PROC(UniformMatrix3fv);
672     GET_PROC(UniformMatrix4fv);
673     GET_PROC(UseProgram);
674     GET_PROC(VertexAttrib1f);
675     GET_PROC(VertexAttrib2fv);
676     GET_PROC(VertexAttrib3fv);
677     GET_PROC(VertexAttrib4fv);
678 
679     if (version >= GR_GL_VER(3,0)) {
680         GET_PROC(VertexAttribDivisor);
681     } else if (extensions.has("GL_EXT_instanced_arrays")) {
682         GET_PROC_SUFFIX(VertexAttribDivisor, EXT);
683     }
684 
685     if (version >= GR_GL_VER(3,0)) {
686         GET_PROC(VertexAttribIPointer);
687     }
688 
689     GET_PROC(VertexAttribPointer);
690     GET_PROC(Viewport);
691     GET_PROC(BindFramebuffer);
692     GET_PROC(BindRenderbuffer);
693     GET_PROC(CheckFramebufferStatus);
694     GET_PROC(DeleteFramebuffers);
695     GET_PROC(DeleteRenderbuffers);
696     GET_PROC(FramebufferRenderbuffer);
697     GET_PROC(FramebufferTexture2D);
698 
699     if (extensions.has("GL_CHROMIUM_framebuffer_multisample")) {
700         GET_PROC_SUFFIX(RenderbufferStorageMultisample, CHROMIUM);
701         GET_PROC_SUFFIX(BlitFramebuffer, CHROMIUM);
702     } else if (version >= GR_GL_VER(3,0)) {
703         GET_PROC(RenderbufferStorageMultisample);
704         GET_PROC(BlitFramebuffer);
705     }
706 
707     if (extensions.has("GL_CHROMIUM_map_sub")) {
708         GET_PROC_SUFFIX(MapBufferSubData, CHROMIUM);
709         GET_PROC_SUFFIX(MapTexSubImage2D, CHROMIUM);
710         GET_PROC_SUFFIX(UnmapBufferSubData, CHROMIUM);
711         GET_PROC_SUFFIX(UnmapTexSubImage2D, CHROMIUM);
712     }
713 
714     if (extensions.has("GL_EXT_multisampled_render_to_texture")) {
715         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, EXT);
716         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleEXT");
717     } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) {
718         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, IMG);
719         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleIMG");
720     } else if (extensions.has("GL_APPLE_framebuffer_multisample")) {
721         functions->fRenderbufferStorageMultisampleES2APPLE = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleAPPLE");
722         GET_PROC_SUFFIX(ResolveMultisampleFramebuffer, APPLE);
723     }
724 
725     GET_PROC(GenFramebuffers);
726     GET_PROC(GenRenderbuffers);
727     GET_PROC(GetFramebufferAttachmentParameteriv);
728     GET_PROC(GetRenderbufferParameteriv);
729     GET_PROC(RenderbufferStorage);
730 
731     GET_PROC_SUFFIX(MapBuffer, OES);
732     GET_PROC_SUFFIX(UnmapBuffer, OES);
733 
734     if (version >= GR_GL_VER(3,0)) {
735         GET_PROC(MapBufferRange);
736         GET_PROC(FlushMappedBufferRange);
737     } else if (extensions.has("GL_EXT_map_buffer_range")) {
738         GET_PROC_SUFFIX(MapBufferRange, EXT);
739         GET_PROC_SUFFIX(FlushMappedBufferRange, EXT);
740     }
741 
742     if (extensions.has("GL_EXT_debug_marker")) {
743         GET_PROC(InsertEventMarker);
744         GET_PROC(PushGroupMarker);
745         GET_PROC(PopGroupMarker);
746         // The below check is here because a device has been found that has the extension string but
747         // returns nullptr from the eglGetProcAddress for the functions
748         if (nullptr == functions->fInsertEventMarker ||
749             nullptr == functions->fPushGroupMarker ||
750             nullptr == functions->fPopGroupMarker) {
751             extensions.remove("GL_EXT_debug_marker");
752         }
753     }
754 
755     GET_PROC(InvalidateFramebuffer);
756     GET_PROC(InvalidateSubFramebuffer);
757     GET_PROC(InvalidateBufferData);
758     GET_PROC(InvalidateBufferSubData);
759     GET_PROC(InvalidateTexImage);
760     GET_PROC(InvalidateTexSubImage);
761 
762     if (version >= GR_GL_VER(3,1)) {
763         GET_PROC(GetProgramResourceLocation);
764     }
765 
766     if (extensions.has("GL_NV_path_rendering")) {
767         GET_PROC_SUFFIX(MatrixLoadf, EXT);
768         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
769         GET_PROC_SUFFIX(PathCommands, NV);
770         GET_PROC_SUFFIX(PathParameteri, NV);
771         GET_PROC_SUFFIX(PathParameterf, NV);
772         GET_PROC_SUFFIX(GenPaths, NV);
773         GET_PROC_SUFFIX(DeletePaths, NV);
774         GET_PROC_SUFFIX(IsPath, NV);
775         GET_PROC_SUFFIX(PathStencilFunc, NV);
776         GET_PROC_SUFFIX(StencilFillPath, NV);
777         GET_PROC_SUFFIX(StencilStrokePath, NV);
778         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
779         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
780         GET_PROC_SUFFIX(CoverFillPath, NV);
781         GET_PROC_SUFFIX(CoverStrokePath, NV);
782         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
783         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
784         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
785         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
786         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
787         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
788         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
789     }
790 
791     if (extensions.has("GL_CHROMIUM_path_rendering")) {
792         GET_PROC_SUFFIX(MatrixLoadf, CHROMIUM);
793         GET_PROC_SUFFIX(MatrixLoadIdentity, CHROMIUM);
794         GET_PROC_SUFFIX(PathCommands, CHROMIUM);
795         GET_PROC_SUFFIX(PathParameteri, CHROMIUM);
796         GET_PROC_SUFFIX(PathParameterf, CHROMIUM);
797         GET_PROC_SUFFIX(GenPaths, CHROMIUM);
798         GET_PROC_SUFFIX(DeletePaths, CHROMIUM);
799         GET_PROC_SUFFIX(IsPath, CHROMIUM);
800         GET_PROC_SUFFIX(PathStencilFunc, CHROMIUM);
801         GET_PROC_SUFFIX(StencilFillPath, CHROMIUM);
802         GET_PROC_SUFFIX(StencilStrokePath, CHROMIUM);
803         GET_PROC_SUFFIX(StencilFillPathInstanced, CHROMIUM);
804         GET_PROC_SUFFIX(StencilStrokePathInstanced, CHROMIUM);
805         GET_PROC_SUFFIX(CoverFillPath, CHROMIUM);
806         GET_PROC_SUFFIX(CoverStrokePath, CHROMIUM);
807         GET_PROC_SUFFIX(CoverFillPathInstanced, CHROMIUM);
808         GET_PROC_SUFFIX(CoverStrokePathInstanced, CHROMIUM);
809         GET_PROC_SUFFIX(StencilThenCoverFillPath, CHROMIUM);
810         GET_PROC_SUFFIX(StencilThenCoverStrokePath, CHROMIUM);
811         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, CHROMIUM);
812         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, CHROMIUM);
813         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, CHROMIUM);
814         // GL_CHROMIUM_path_rendering additions:
815         GET_PROC_SUFFIX(BindFragmentInputLocation, CHROMIUM);
816     }
817 
818     if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
819         GET_PROC_SUFFIX(CoverageModulation, NV);
820     }
821     if (extensions.has("GL_CHROMIUM_framebuffer_mixed_samples")) {
822         GET_PROC_SUFFIX(CoverageModulation, CHROMIUM);
823     }
824 
825     if (extensions.has("GL_EXT_multi_draw_indirect")) {
826         GET_PROC_SUFFIX(MultiDrawArraysIndirect, EXT);
827         GET_PROC_SUFFIX(MultiDrawElementsIndirect, EXT);
828     }
829 
830     if (extensions.has("GL_NV_bindless_texture")) {
831         GET_PROC_SUFFIX(GetTextureHandle, NV);
832         GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
833         GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
834         GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
835         GET_PROC_SUFFIX(GetImageHandle, NV);
836         GET_PROC_SUFFIX(MakeImageHandleResident, NV);
837         GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
838         GET_PROC_SUFFIX(IsTextureHandleResident, NV);
839         GET_PROC_SUFFIX(IsImageHandleResident, NV);
840         GET_PROC_SUFFIX(UniformHandleui64, NV);
841         GET_PROC_SUFFIX(UniformHandleui64v, NV);
842         GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
843         GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
844     }
845 
846     if (extensions.has("GL_KHR_debug")) {
847         GET_PROC_SUFFIX(DebugMessageControl, KHR);
848         GET_PROC_SUFFIX(DebugMessageInsert, KHR);
849         GET_PROC_SUFFIX(DebugMessageCallback, KHR);
850         GET_PROC_SUFFIX(GetDebugMessageLog, KHR);
851         GET_PROC_SUFFIX(PushDebugGroup, KHR);
852         GET_PROC_SUFFIX(PopDebugGroup, KHR);
853         GET_PROC_SUFFIX(ObjectLabel, KHR);
854         // In general we have a policy against removing extension strings when the driver does
855         // not provide function pointers for an advertised extension. However, because there is a
856         // known device that advertises GL_KHR_debug but fails to provide the functions and this is
857         // a debugging- only extension we've made an exception. This also can happen when using
858         // APITRACE.
859         if (!interface->fFunctions.fDebugMessageControl) {
860             extensions.remove("GL_KHR_debug");
861         }
862     }
863 
864     if (extensions.has("GL_CHROMIUM_bind_uniform_location")) {
865         GET_PROC_SUFFIX(BindUniformLocation, CHROMIUM);
866     }
867 
868     if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
869         GET_EGL_PROC_SUFFIX(CreateImage, KHR);
870         GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
871     }
872 
873     interface->fStandard = kGLES_GrGLStandard;
874     interface->fExtensions.swap(&extensions);
875 
876     return interface;
877 }
878