Implement support for using GL ES 3.0 with command buffer

src/gpu/gl/command_buffer/SkCommandBufferGLContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOnce.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLAssembleInterface.h"
@@ skipping 15 matching lines @@
 typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_FALSE 0
 #define EGL_OPENGL_ES2_BIT 0x0004
 #define EGL_CONTEXT_CLIENT_VERSION 0x3098
 #define EGL_NO_SURFACE ((EGLSurface)0)
 #define EGL_NO_DISPLAY ((EGLDisplay)0)
 #define EGL_NO_CONTEXT ((EGLContext)0)
 #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
 #define EGL_SURFACE_TYPE 0x3033
 #define EGL_PBUFFER_BIT 0x0001
+#define EGL_WINDOW_BIT 0x0004
 #define EGL_RENDERABLE_TYPE 0x3040
 #define EGL_RED_SIZE 0x3024
 #define EGL_GREEN_SIZE 0x3023
 #define EGL_BLUE_SIZE 0x3022
 #define EGL_ALPHA_SIZE 0x3021
 #define EGL_DEPTH_SIZE 0x3025
 #define EGL_STENCIL_SIZE 0x3025
 #define EGL_SAMPLES 0x3031
 #define EGL_SAMPLE_BUFFERS 0x3032
 #define EGL_NONE 0x3038
 #define EGL_WIDTH 0x3057
 #define EGL_HEIGHT 0x3056
 
 #else
 
 #include <EGL/egl.h>
 
 #endif
 
+#ifndef EGL_OPENGL_ES3_BIT
+// Part of EGL 1.5, typical headers are 1.4.
+#define EGL_OPENGL_ES3_BIT 0x0040
+#endif
+
 typedef EGLDisplay (*GetDisplayProc)(EGLNativeDisplayType display_id);
 typedef EGLBoolean (*InitializeProc)(EGLDisplay dpy, EGLint *major, EGLint *minor);
 typedef EGLBoolean (*TerminateProc)(EGLDisplay dpy);
 typedef EGLBoolean (*ChooseConfigProc)(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
 typedef EGLBoolean (*GetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
 typedef EGLSurface (*CreateWindowSurfaceProc)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list);
 typedef EGLSurface (*CreatePbufferSurfaceProc)(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroySurfaceProc)(EGLDisplay dpy, EGLSurface surface);
 typedef EGLContext (*CreateContextProc)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroyContextProc)(EGLDisplay dpy, EGLContext ctx);
@@ skipping 65 matching lines @@
 }
 
 const GrGLInterface* GrGLCreateCommandBufferInterface() {
     LoadCommandBufferOnce();
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
     return GrGLAssembleGLESInterface(gLibrary, command_buffer_get_gl_proc);
 }
 
-SkCommandBufferGLContext::SkCommandBufferGLContext()
+SkCommandBufferGLContext::SkCommandBufferGLContext(ContextVersion minContextVersion)
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
     , fSurface(EGL_NO_SURFACE) {
 
     static const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_RENDERABLE_TYPE, minContextVersion == kGLES3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT,
         EGL_RED_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_ALPHA_SIZE, 8,
         EGL_NONE
     };
 
     static const EGLint surfaceAttribs[] = {
         EGL_WIDTH, 1,
         EGL_HEIGHT, 1,
         EGL_NONE
     };
 
-    initializeGLContext(nullptr, configAttribs, surfaceAttribs);
+    initializeGLContext(minContextVersion, nullptr, configAttribs, surfaceAttribs);
 }
 
 SkCommandBufferGLContext::SkCommandBufferGLContext(void* nativeWindow, int msaaSampleCount) {
     static const EGLint surfaceAttribs[] = { EGL_NONE };
 
     EGLint configAttribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_RED_SIZE,       8,
         EGL_GREEN_SIZE,     8,
         EGL_BLUE_SIZE,      8,
         EGL_ALPHA_SIZE,     8,
         EGL_DEPTH_SIZE,     8,
         EGL_STENCIL_SIZE,   8,
         EGL_SAMPLE_BUFFERS, 1,
         EGL_SAMPLES,        msaaSampleCount,
         EGL_NONE
     };
     if (msaaSampleCount == 0) {
         configAttribs[12] = EGL_NONE;
     }
 
-    initializeGLContext(nativeWindow, configAttribs, surfaceAttribs);
+    initializeGLContext(kGLES2, nativeWindow, configAttribs, surfaceAttribs);
 }
 
-void SkCommandBufferGLContext::initializeGLContext(void* nativeWindow, const int* configAttribs,
+void SkCommandBufferGLContext::initializeGLContext(ContextVersion minContextVersion,
+                                                   void* nativeWindow, const int* configAttribs,
                                                    const int* surfaceAttribs) {
     LoadCommandBufferOnce();
     if (!gfFunctionsLoadedSuccessfully) {
         SkDebugf("Command Buffer: Could not load EGL functions.\n");
         return;
     }
 
     // Make sure CHROMIUM_path_rendering is enabled for NVPR support.
     sk_setenv("CHROME_COMMAND_BUFFER_GLES2_ARGS", "--enable-gl-path-rendering");
     fDisplay = gfGetDisplay(EGL_DEFAULT_DISPLAY);
@@ skipping 28 matching lines @@
                                           static_cast<EGLConfig>(fConfig),
                                           surfaceAttribs);
     }
     if (EGL_NO_SURFACE == fSurface) {
         SkDebugf("Command Buffer: Could not create EGL surface.\n");
         this->destroyGLContext();
         return;
     }
 
     static const EGLint contextAttribs[] = {
-        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_CONTEXT_CLIENT_VERSION, minContextVersion == kGLES3 ? 3 : 2,
         EGL_NONE
     };
     fContext = gfCreateContext(fDisplay, static_cast<EGLConfig>(fConfig), nullptr, contextAttribs);
     if (EGL_NO_CONTEXT == fContext) {
         SkDebugf("Command Buffer: Could not create EGL context.\n");
         this->destroyGLContext();
         return;
     }
 
     if (!gfMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
@@ skipping 85 matching lines @@
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_STENCIL_SIZE, &result);
     return result;
 }
 
 int SkCommandBufferGLContext::getSampleCount() {
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_SAMPLES, &result);
     return result;
 }