blob: 559fc4a25ba169feaa228e821cc4e4e5241b0c59 [file] [log] [blame]
/*
* 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 "include/core/SkTypes.h"
#if defined(SK_BUILD_FOR_WIN) && !defined(_M_ARM64)
#include "src/utils/win/SkWGL.h"
#include "include/private/SkOnce.h"
#include "include/private/SkTDArray.h"
#include "src/core/SkTSearch.h"
#include "src/core/SkTSort.h"
bool SkWGLExtensions::hasExtension(HDC dc, const char* ext) const {
if (nullptr == this->fGetExtensionsString) {
return false;
}
if (!strcmp("WGL_ARB_extensions_string", ext)) {
return true;
}
const char* extensionString = this->getExtensionsString(dc);
size_t extLength = strlen(ext);
while (true) {
size_t n = strcspn(extensionString, " ");
if (n == extLength && 0 == strncmp(ext, extensionString, n)) {
return true;
}
if (0 == extensionString[n]) {
return false;
}
extensionString += n+1;
}
return false;
}
const char* SkWGLExtensions::getExtensionsString(HDC hdc) const {
return fGetExtensionsString(hdc);
}
BOOL SkWGLExtensions::choosePixelFormat(HDC hdc,
const int* piAttribIList,
const FLOAT* pfAttribFList,
UINT nMaxFormats,
int* piFormats,
UINT* nNumFormats) const {
return fChoosePixelFormat(hdc, piAttribIList, pfAttribFList,
nMaxFormats, piFormats, nNumFormats);
}
BOOL SkWGLExtensions::getPixelFormatAttribiv(HDC hdc,
int iPixelFormat,
int iLayerPlane,
UINT nAttributes,
const int *piAttributes,
int *piValues) const {
return fGetPixelFormatAttribiv(hdc, iPixelFormat, iLayerPlane,
nAttributes, piAttributes, piValues);
}
BOOL SkWGLExtensions::getPixelFormatAttribfv(HDC hdc,
int iPixelFormat,
int iLayerPlane,
UINT nAttributes,
const int *piAttributes,
float *pfValues) const {
return fGetPixelFormatAttribfv(hdc, iPixelFormat, iLayerPlane,
nAttributes, piAttributes, pfValues);
}
HGLRC SkWGLExtensions::createContextAttribs(HDC hDC,
HGLRC hShareContext,
const int *attribList) const {
return fCreateContextAttribs(hDC, hShareContext, attribList);
}
BOOL SkWGLExtensions::swapInterval(int interval) const {
return fSwapInterval(interval);
}
HPBUFFER SkWGLExtensions::createPbuffer(HDC hDC,
int iPixelFormat,
int iWidth,
int iHeight,
const int *piAttribList) const {
return fCreatePbuffer(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
}
HDC SkWGLExtensions::getPbufferDC(HPBUFFER hPbuffer) const {
return fGetPbufferDC(hPbuffer);
}
int SkWGLExtensions::releasePbufferDC(HPBUFFER hPbuffer, HDC hDC) const {
return fReleasePbufferDC(hPbuffer, hDC);
}
BOOL SkWGLExtensions::destroyPbuffer(HPBUFFER hPbuffer) const {
return fDestroyPbuffer(hPbuffer);
}
namespace {
struct PixelFormat {
int fFormat;
int fSampleCnt;
int fChoosePixelFormatRank;
};
bool pf_less(const PixelFormat& a, const PixelFormat& b) {
if (a.fSampleCnt < b.fSampleCnt) {
return true;
} else if (b.fSampleCnt < a.fSampleCnt) {
return false;
} else if (a.fChoosePixelFormatRank < b.fChoosePixelFormatRank) {
return true;
}
return false;
}
}
int SkWGLExtensions::selectFormat(const int formats[],
int formatCount,
HDC dc,
int desiredSampleCount) const {
SkASSERT(desiredSampleCount >= 1);
if (formatCount <= 0) {
return -1;
}
PixelFormat desiredFormat = {
0,
desiredSampleCount,
0,
};
SkTDArray<PixelFormat> rankedFormats;
rankedFormats.setCount(formatCount);
for (int i = 0; i < formatCount; ++i) {
static const int kQueryAttr = SK_WGL_SAMPLES;
int numSamples;
this->getPixelFormatAttribiv(dc,
formats[i],
0,
1,
&kQueryAttr,
&numSamples);
rankedFormats[i].fFormat = formats[i];
rankedFormats[i].fSampleCnt = SkTMax(1, numSamples);
rankedFormats[i].fChoosePixelFormatRank = i;
}
SkTQSort(rankedFormats.begin(),
rankedFormats.begin() + rankedFormats.count() - 1,
SkTLessFunctionToFunctorAdaptor<PixelFormat, pf_less>());
int idx = SkTSearch<PixelFormat, pf_less>(rankedFormats.begin(),
rankedFormats.count(),
desiredFormat,
sizeof(PixelFormat));
if (idx < 0) {
idx = ~idx;
}
// If the caller asked for non-MSAA fail if the closest format has MSAA.
if (desiredSampleCount == 1 && rankedFormats[idx].fSampleCnt != 1) {
return -1;
}
return rankedFormats[idx].fFormat;
}
namespace {
#if defined(UNICODE)
#define STR_LIT(X) L## #X
#else
#define STR_LIT(X) #X
#endif
#define DUMMY_CLASS STR_LIT("DummyClass")
HWND create_dummy_window() {
HMODULE module = GetModuleHandle(nullptr);
HWND dummy;
RECT windowRect;
windowRect.left = 0;
windowRect.right = 8;
windowRect.top = 0;
windowRect.bottom = 8;
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) DefWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = module;
wc.hIcon = LoadIcon(nullptr, IDI_WINLOGO);
wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
wc.hbrBackground = nullptr;
wc.lpszMenuName = nullptr;
wc.lpszClassName = DUMMY_CLASS;
if(!RegisterClass(&wc)) {
return 0;
}
DWORD style, exStyle;
exStyle = WS_EX_CLIENTEDGE;
style = WS_SYSMENU;
AdjustWindowRectEx(&windowRect, style, false, exStyle);
if(!(dummy = CreateWindowEx(exStyle,
DUMMY_CLASS,
STR_LIT("DummyWindow"),
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style,
0, 0,
windowRect.right-windowRect.left,
windowRect.bottom-windowRect.top,
nullptr, nullptr,
module,
nullptr))) {
UnregisterClass(DUMMY_CLASS, module);
return nullptr;
}
ShowWindow(dummy, SW_HIDE);
return dummy;
}
void destroy_dummy_window(HWND dummy) {
DestroyWindow(dummy);
HMODULE module = GetModuleHandle(nullptr);
UnregisterClass(DUMMY_CLASS, module);
}
}
#define GET_PROC(NAME, SUFFIX) f##NAME = \
(NAME##Proc) wglGetProcAddress("wgl" #NAME #SUFFIX)
SkWGLExtensions::GetExtensionsStringProc SkWGLExtensions::fGetExtensionsString = nullptr;
SkWGLExtensions::ChoosePixelFormatProc SkWGLExtensions::fChoosePixelFormat = nullptr;
SkWGLExtensions::GetPixelFormatAttribfvProc SkWGLExtensions::fGetPixelFormatAttribfv = nullptr;
SkWGLExtensions::GetPixelFormatAttribivProc SkWGLExtensions::fGetPixelFormatAttribiv = nullptr;
SkWGLExtensions::CreateContextAttribsProc SkWGLExtensions::fCreateContextAttribs = nullptr;
SkWGLExtensions::SwapIntervalProc SkWGLExtensions::fSwapInterval = nullptr;
SkWGLExtensions::CreatePbufferProc SkWGLExtensions::fCreatePbuffer = nullptr;
SkWGLExtensions::GetPbufferDCProc SkWGLExtensions::fGetPbufferDC = nullptr;
SkWGLExtensions::ReleasePbufferDCProc SkWGLExtensions::fReleasePbufferDC = nullptr;
SkWGLExtensions::DestroyPbufferProc SkWGLExtensions::fDestroyPbuffer = nullptr;
SkWGLExtensions::SkWGLExtensions() {
// We cache these function pointers once, and then reuse them. That's possibly incorrect if
// there are multiple GPUs, or if we intend to use these for rendering contexts of different
// pixel formats (where wglGetProcAddress is not guaranteed to return the same pointer).
static SkOnce once;
once([] {
HDC prevDC = wglGetCurrentDC();
HGLRC prevGLRC = wglGetCurrentContext();
PIXELFORMATDESCRIPTOR dummyPFD;
ZeroMemory(&dummyPFD, sizeof(dummyPFD));
dummyPFD.nSize = sizeof(dummyPFD);
dummyPFD.nVersion = 1;
dummyPFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
dummyPFD.iPixelType = PFD_TYPE_RGBA;
dummyPFD.cColorBits = 32;
dummyPFD.cDepthBits = 0;
dummyPFD.cStencilBits = 8;
dummyPFD.iLayerType = PFD_MAIN_PLANE;
HWND dummyWND = create_dummy_window();
if (dummyWND) {
HDC dummyDC = GetDC(dummyWND);
int dummyFormat = ChoosePixelFormat(dummyDC, &dummyPFD);
SetPixelFormat(dummyDC, dummyFormat, &dummyPFD);
HGLRC dummyGLRC = wglCreateContext(dummyDC);
SkASSERT(dummyGLRC);
wglMakeCurrent(dummyDC, dummyGLRC);
GET_PROC(GetExtensionsString, ARB);
GET_PROC(ChoosePixelFormat, ARB);
GET_PROC(GetPixelFormatAttribiv, ARB);
GET_PROC(GetPixelFormatAttribfv, ARB);
GET_PROC(CreateContextAttribs, ARB);
GET_PROC(SwapInterval, EXT);
GET_PROC(CreatePbuffer, ARB);
GET_PROC(GetPbufferDC, ARB);
GET_PROC(ReleasePbufferDC, ARB);
GET_PROC(DestroyPbuffer, ARB);
wglMakeCurrent(dummyDC, nullptr);
wglDeleteContext(dummyGLRC);
destroy_dummy_window(dummyWND);
}
wglMakeCurrent(prevDC, prevGLRC);
});
}
///////////////////////////////////////////////////////////////////////////////
static void get_pixel_formats_to_try(HDC dc, const SkWGLExtensions& extensions,
bool doubleBuffered, int msaaSampleCount, bool deepColor,
int formatsToTry[2]) {
auto appendAttr = [](SkTDArray<int>& attrs, int attr, int value) {
attrs.push_back(attr);
attrs.push_back(value);
};
SkTDArray<int> iAttrs;
appendAttr(iAttrs, SK_WGL_DRAW_TO_WINDOW, TRUE);
appendAttr(iAttrs, SK_WGL_DOUBLE_BUFFER, (doubleBuffered ? TRUE : FALSE));
appendAttr(iAttrs, SK_WGL_ACCELERATION, SK_WGL_FULL_ACCELERATION);
appendAttr(iAttrs, SK_WGL_SUPPORT_OPENGL, TRUE);
if (deepColor) {
appendAttr(iAttrs, SK_WGL_RED_BITS, 10);
appendAttr(iAttrs, SK_WGL_GREEN_BITS, 10);
appendAttr(iAttrs, SK_WGL_BLUE_BITS, 10);
appendAttr(iAttrs, SK_WGL_ALPHA_BITS, 2);
} else {
appendAttr(iAttrs, SK_WGL_COLOR_BITS, 24);
appendAttr(iAttrs, SK_WGL_ALPHA_BITS, 8);
}
appendAttr(iAttrs, SK_WGL_STENCIL_BITS, 8);
float fAttrs[] = {0, 0};
// Get a MSAA format if requested and possible.
if (msaaSampleCount > 0 &&
extensions.hasExtension(dc, "WGL_ARB_multisample")) {
SkTDArray<int> msaaIAttrs = iAttrs;
appendAttr(msaaIAttrs, SK_WGL_SAMPLE_BUFFERS, TRUE);
appendAttr(msaaIAttrs, SK_WGL_SAMPLES, msaaSampleCount);
appendAttr(msaaIAttrs, 0, 0);
unsigned int num;
int formats[64];
extensions.choosePixelFormat(dc, msaaIAttrs.begin(), fAttrs, 64, formats, &num);
num = SkTMin(num, 64U);
formatsToTry[0] = extensions.selectFormat(formats, num, dc, msaaSampleCount);
}
// Get a non-MSAA format
int* format = -1 == formatsToTry[0] ? &formatsToTry[0] : &formatsToTry[1];
unsigned int num;
appendAttr(iAttrs, 0, 0);
extensions.choosePixelFormat(dc, iAttrs.begin(), fAttrs, 1, format, &num);
}
static HGLRC create_gl_context(HDC dc, const SkWGLExtensions& extensions,
SkWGLContextRequest contextType, HGLRC shareContext) {
HDC prevDC = wglGetCurrentDC();
HGLRC prevGLRC = wglGetCurrentContext();
HGLRC glrc = nullptr;
if (kGLES_SkWGLContextRequest == contextType) {
if (!extensions.hasExtension(dc, "WGL_EXT_create_context_es2_profile")) {
wglMakeCurrent(prevDC, prevGLRC);
return nullptr;
}
static const int glesAttribs[] = {
SK_WGL_CONTEXT_MAJOR_VERSION, 3,
SK_WGL_CONTEXT_MINOR_VERSION, 0,
SK_WGL_CONTEXT_PROFILE_MASK, SK_WGL_CONTEXT_ES2_PROFILE_BIT,
0,
};
glrc = extensions.createContextAttribs(dc, shareContext, glesAttribs);
if (nullptr == glrc) {
wglMakeCurrent(prevDC, prevGLRC);
return nullptr;
}
} else {
if (kGLPreferCoreProfile_SkWGLContextRequest == contextType &&
extensions.hasExtension(dc, "WGL_ARB_create_context")) {
static const int kCoreGLVersions[] = {
4, 3,
4, 2,
4, 1,
4, 0,
3, 3,
3, 2,
};
int coreProfileAttribs[] = {
SK_WGL_CONTEXT_MAJOR_VERSION, -1,
SK_WGL_CONTEXT_MINOR_VERSION, -1,
SK_WGL_CONTEXT_PROFILE_MASK, SK_WGL_CONTEXT_CORE_PROFILE_BIT,
0,
};
for (size_t v = 0; v < SK_ARRAY_COUNT(kCoreGLVersions) / 2; ++v) {
coreProfileAttribs[1] = kCoreGLVersions[2 * v];
coreProfileAttribs[3] = kCoreGLVersions[2 * v + 1];
glrc = extensions.createContextAttribs(dc, shareContext, coreProfileAttribs);
if (glrc) {
break;
}
}
}
}
if (nullptr == glrc) {
glrc = wglCreateContext(dc);
if (shareContext) {
if (!wglShareLists(shareContext, glrc)) {
wglDeleteContext(glrc);
return nullptr;
}
}
}
SkASSERT(glrc);
wglMakeCurrent(prevDC, prevGLRC);
return glrc;
}
HGLRC SkCreateWGLContext(HDC dc, int msaaSampleCount, bool deepColor,
SkWGLContextRequest contextType, HGLRC shareContext) {
SkWGLExtensions extensions;
if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {
return nullptr;
}
BOOL set = FALSE;
int pixelFormatsToTry[] = { -1, -1 };
get_pixel_formats_to_try(dc, extensions, true, msaaSampleCount, deepColor, pixelFormatsToTry);
for (size_t f = 0;
!set && -1 != pixelFormatsToTry[f] && f < SK_ARRAY_COUNT(pixelFormatsToTry);
++f) {
PIXELFORMATDESCRIPTOR pfd;
DescribePixelFormat(dc, pixelFormatsToTry[f], sizeof(pfd), &pfd);
set = SetPixelFormat(dc, pixelFormatsToTry[f], &pfd);
}
if (!set) {
return nullptr;
}
return create_gl_context(dc, extensions, contextType, shareContext);
}
sk_sp<SkWGLPbufferContext> SkWGLPbufferContext::Create(HDC parentDC,
SkWGLContextRequest contextType,
HGLRC shareContext) {
SkWGLExtensions extensions;
if (!extensions.hasExtension(parentDC, "WGL_ARB_pixel_format") ||
!extensions.hasExtension(parentDC, "WGL_ARB_pbuffer")) {
return nullptr;
}
// We cache the pixel formats once, and then reuse them. That's possibly incorrect if
// there are multiple GPUs, but this function is always called with a freshly made,
// identically constructed HDC (see WinGLTestContext).
//
// We only store two potential pixel formats, one for single buffer, one for double buffer.
// We never ask for MSAA, so we don't need the second pixel format for each buffering state.
static int gPixelFormats[2] = { -1, -1 };
static SkOnce once;
once([=] {
{
// Single buffer
int pixelFormatsToTry[2] = { -1, -1 };
get_pixel_formats_to_try(parentDC, extensions, false, 0, false, pixelFormatsToTry);
gPixelFormats[0] = pixelFormatsToTry[0];
}
{
// Double buffer
int pixelFormatsToTry[2] = { -1, -1 };
get_pixel_formats_to_try(parentDC, extensions, true, 0, false, pixelFormatsToTry);
gPixelFormats[1] = pixelFormatsToTry[0];
}
});
// try for single buffer first
for (int pixelFormat : gPixelFormats) {
if (-1 == pixelFormat) {
continue;
}
HPBUFFER pbuf = extensions.createPbuffer(parentDC, pixelFormat, 1, 1, nullptr);
if (0 != pbuf) {
HDC dc = extensions.getPbufferDC(pbuf);
if (dc) {
HGLRC glrc = create_gl_context(dc, extensions, contextType, shareContext);
if (glrc) {
return sk_sp<SkWGLPbufferContext>(new SkWGLPbufferContext(pbuf, dc, glrc));
}
extensions.releasePbufferDC(pbuf, dc);
}
extensions.destroyPbuffer(pbuf);
}
}
return nullptr;
}
SkWGLPbufferContext::~SkWGLPbufferContext() {
SkASSERT(fExtensions.hasExtension(fDC, "WGL_ARB_pbuffer"));
wglDeleteContext(fGLRC);
fExtensions.releasePbufferDC(fPbuffer, fDC);
fExtensions.destroyPbuffer(fPbuffer);
}
SkWGLPbufferContext::SkWGLPbufferContext(HPBUFFER pbuffer, HDC dc, HGLRC glrc)
: fPbuffer(pbuffer)
, fDC(dc)
, fGLRC(glrc) {
}
#endif//defined(SK_BUILD_FOR_WIN)