Make SkOSWindow return the sample count and stencil bit count for its GL context.

src/views/win/SkOSWindow_win.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkTypes.h"
 
 #if defined(SK_BUILD_FOR_WIN)
@@ skipping 415 matching lines @@
 
     if (NULL == glrc) {
         glrc = wglCreateContext(dc);
     }
     SkASSERT(glrc);
 
     wglMakeCurrent(prevDC, prevGLRC);
     return glrc;
 }
 
-bool SkOSWindow::attachGL(int msaaSampleCount) {
+bool SkOSWindow::attachGL(int msaaSampleCount, AttachmentInfo* info) {
     if (NULL == fHGLRC) {
         fHGLRC = create_gl((HWND)fHWND, msaaSampleCount);
         if (NULL == fHGLRC) {
             return false;
         }
         glClearStencil(0);
         glClearColor(0, 0, 0, 0);
         glStencilMask(0xffffffff);
         glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
     }
-    if (wglMakeCurrent(GetDC((HWND)fHWND), (HGLRC)fHGLRC)) {
-        glViewport(0, 0, SkScalarRound(this->width()),
-                   SkScalarRound(this->height()));
+    HDC dc = GetDC((HWND)fHWND);
+    if (wglMakeCurrent(dc, (HGLRC)fHGLRC)) {
+        // use DescribePixelFormat to get the stencil bit depth.
+        int pixelFormat = GetPixelFormat(dc);
+        PIXELFORMATDESCRIPTOR pfd;
+        DescribePixelFormat(dc, pixelFormat, sizeof(pfd), &pfd);
+        info->fStencilBits = pfd.cStencilBits;
+
+        // Get sample count if the the MSAA WGL extension is present
+        SkWGLExtensions extensions;
+        if (extensions.hasExtension(dc, "WGL_ARB_multisample")) {
+            static const int kSampleCountAttr = SK_WGL_SAMPLES;
+            extensions.getPixelFormatAttribiv(dc,
+                                              pixelFormat,
+                                              0,
+                                              1,
+                                              &kSampleCountAttr,
+                                              &info->fSampleCount);
+        } else {
+            info->fSampleCount = 0;
+        }
+
+        glViewport(0, 0, SkScalarRound(this->width()), SkScalarRound(this->height()));
         return true;
     }
     return false;
 }
 
 void SkOSWindow::detachGL() {
     wglMakeCurrent(GetDC((HWND)fHWND), 0);
     wglDeleteContext((HGLRC)fHGLRC);
     fHGLRC = NULL;
 }
 
 void SkOSWindow::presentGL() {
     glFlush();
     SwapBuffers(GetDC((HWND)fHWND));
 }
 
 #if SK_ANGLE
 bool create_ANGLE(EGLNativeWindowType hWnd,
                   int msaaSampleCount,
                   EGLDisplay* eglDisplay,
                   EGLContext* eglContext,
-                  EGLSurface* eglSurface) {
+                  EGLSurface* eglSurface,
+                  EGLConfig* eglConfig) {
     static const EGLint contextAttribs[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE, EGL_NONE
     };
     static const EGLint configAttribList[] = {
         EGL_RED_SIZE,       8,
         EGL_GREEN_SIZE,     8,
         EGL_BLUE_SIZE,      8,
         EGL_ALPHA_SIZE,     8,
         EGL_DEPTH_SIZE,     8,
@@ skipping 14 matching lines @@
     if (!eglInitialize(display, &majorVersion, &minorVersion)) {
        return false;
     }
 
     EGLint numConfigs;
     if (!eglGetConfigs(display, NULL, 0, &numConfigs)) {
        return false;
     }
 
     // Choose config
-    EGLConfig config;
     bool foundConfig = false;
     if (msaaSampleCount) {
         static const int kConfigAttribListCnt =
                                 SK_ARRAY_COUNT(configAttribList);
         EGLint msaaConfigAttribList[kConfigAttribListCnt + 4];
         memcpy(msaaConfigAttribList,
                configAttribList,
                sizeof(configAttribList));
         SkASSERT(EGL_NONE == msaaConfigAttribList[kConfigAttribListCnt - 1]);
         msaaConfigAttribList[kConfigAttribListCnt - 1] = EGL_SAMPLE_BUFFERS;
         msaaConfigAttribList[kConfigAttribListCnt + 0] = 1;
         msaaConfigAttribList[kConfigAttribListCnt + 1] = EGL_SAMPLES;
         msaaConfigAttribList[kConfigAttribListCnt + 2] = msaaSampleCount;
         msaaConfigAttribList[kConfigAttribListCnt + 3] = EGL_NONE;
-        if (eglChooseConfig(display, configAttribList,
-                                   &config, 1, &numConfigs)) {
+        if (eglChooseConfig(display, configAttribList, eglConfig, 1, &numConfigs)) {
             SkASSERT(numConfigs > 0);
             foundConfig = true;
         }
     }
     if (!foundConfig) {
-        if (!eglChooseConfig(display, configAttribList,
-                                    &config, 1, &numConfigs)) {
+        if (!eglChooseConfig(display, configAttribList, eglConfig, 1, &numConfigs)) {
            return false;
         }
     }
 
     // Create a surface
-    EGLSurface surface = eglCreateWindowSurface(display, config,
+    EGLSurface surface = eglCreateWindowSurface(display, *eglConfig,
                                                 (EGLNativeWindowType)hWnd,
                                                 surfaceAttribList);
     if (surface == EGL_NO_SURFACE) {
        return false;
     }
 
     // Create a GL context
-    EGLContext context = eglCreateContext(display, config,
+    EGLContext context = eglCreateContext(display, *eglConfig,
                                           EGL_NO_CONTEXT,
                                           contextAttribs );
     if (context == EGL_NO_CONTEXT ) {
        return false;
     }
 
     // Make the context current
     if (!eglMakeCurrent(display, surface, surface, context)) {
        return false;
     }
 
     *eglDisplay = display;
     *eglContext = context;
     *eglSurface = surface;
     return true;
 }
 
-bool SkOSWindow::attachANGLE(int msaaSampleCount) {
+bool SkOSWindow::attachANGLE(int msaaSampleCount, AttachmentInfo* info) {
     if (EGL_NO_DISPLAY == fDisplay) {
         bool bResult = create_ANGLE((HWND)fHWND,
                                     msaaSampleCount,
                                     &fDisplay,
                                     &fContext,
-                                    &fSurface);
+                                    &fSurface,
+                                    &fConfig);
         if (false == bResult) {
             return false;
         }
         SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
 
         if (intf) {
             ANGLE_GL_CALL(intf, ClearStencil(0));
             ANGLE_GL_CALL(intf, ClearColor(0, 0, 0, 0));
             ANGLE_GL_CALL(intf, StencilMask(0xffffffff));
             ANGLE_GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
         }
     }
     if (eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
+        eglGetConfigAttrib(fDisplay, fConfig, EGL_STENCIL_SIZE, &info->fStencilBits);
+        eglGetConfigAttrib(fDisplay, fConfig, EGL_SAMPLES, &info->fSampleCount);
+
         SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
 
         if (intf ) {
             ANGLE_GL_CALL(intf, Viewport(0, 0, SkScalarRound(this->width()),
                                       SkScalarRound(this->height())));
         }
         return true;
     }
     return false;
 }
@@ skipping 17 matching lines @@
     if (intf) {
         ANGLE_GL_CALL(intf, Flush());
     }
 
     eglSwapBuffers(fDisplay, fSurface);
 }
 #endif // SK_ANGLE
 #endif // SK_SUPPORT_GPU
 
 // return true on success
-bool SkOSWindow::attach(SkBackEndTypes attachType, int msaaSampleCount) {
+bool SkOSWindow::attach(SkBackEndTypes attachType, int msaaSampleCount, AttachmentInfo* info) {
 
     // attach doubles as "windowResize" so we need to allo
     // already bound states to pass through again
     // TODO: split out the resize functionality
 //    SkASSERT(kNone_BackEndType == fAttached);
     bool result = true;
 
     switch (attachType) {
     case kNone_BackEndType:
         // nothing to do
         break;
 #if SK_SUPPORT_GPU
     case kNativeGL_BackEndType:
-        result = attachGL(msaaSampleCount);
+        result = attachGL(msaaSampleCount, info);
         break;
 #if SK_ANGLE
     case kANGLE_BackEndType:
-        result = attachANGLE(msaaSampleCount);
+        result = attachANGLE(msaaSampleCount, info);
         break;
 #endif // SK_ANGLE
 #endif // SK_SUPPORT_GPU
     default:
         SkASSERT(false);
         result = false;
         break;
     }
 
     if (result) {
@@ skipping 40 matching lines @@
         break;
 #endif // SK_ANGLE
 #endif // SK_SUPPORT_GPU
     default:
         SkASSERT(false);
         break;
     }
 }
 
 #endif