ContextInfo GrContextFactory::getContextInfo(ContextType type, ContextOptions options) {
for (int i = 0; i < fContexts.count(); ++i) {
Context& context = fContexts[i];
if (context.fType == type &&
context.fOptions == options &&
!context.fAbandoned) {
if (context.fGLContext) {
context.fGLContext->makeCurrent();
}
return ContextInfo(context.fGrContext, context.fGLContext);
}
}
SkAutoTDelete<GLTestContext> glCtx;
sk_sp<GrContext> grCtx;
GrBackendContext backendContext = 0;
sk_sp<const GrGLInterface> glInterface;
#ifdef SK_VULKAN
sk_sp<const GrVkBackendContext> vkBackend;
#endif
GrBackend backend = ContextTypeBackend(type);
switch (backend) {
case kOpenGL_GrBackend:
switch (type) {
case kGL_ContextType:
glCtx.reset(CreatePlatformGLTestContext(kGL_GrGLStandard));
break;
case kGLES_ContextType:
glCtx.reset(CreatePlatformGLTestContext(kGLES_GrGLStandard));
break;
#if SK_ANGLE
# ifdef SK_BUILD_FOR_WIN
case kANGLE_ContextType:
glCtx.reset(CreateANGLEDirect3DGLTestContext());
break;
# endif
case kANGLE_GL_ContextType:
glCtx.reset(CreateANGLEOpenGLGLTestContext());
break;
#endif
#if SK_COMMAND_BUFFER
case kCommandBuffer_ContextType:
glCtx.reset(CommandBufferGLTestContext::Create());
break;
#endif
#if SK_MESA
case kMESA_ContextType:
glCtx.reset(CreateMesaGLTestContext());
break;
#endif
case kNullGL_ContextType:
glCtx.reset(CreateNullGLTestContext());
break;
case kDebugGL_ContextType:
glCtx.reset(CreateDebugGLTestContext());
break;
default:
return ContextInfo();
}
if (nullptr == glCtx.get()) {
return ContextInfo();
}
glInterface.reset(SkRef(glCtx->gl()));
// Block NVPR from non-NVPR types.
if (!(kEnableNVPR_ContextOptions & options)) {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface.get()));
if (!glInterface) {
return ContextInfo();
}
}
backendContext = reinterpret_cast<GrBackendContext>(glInterface.get());
glCtx->makeCurrent();
break;
#ifdef SK_VULKAN
case kVulkan_GrBackend:
SkASSERT(kVulkan_ContextType == type);
if ((kEnableNVPR_ContextOptions & options) ||
(kRequireSRGBSupport_ContextOptions & options)) {
return ContextInfo();
}
vkBackend.reset(GrVkBackendContext::Create());
if (!vkBackend) {
return ContextInfo();
}
backendContext = reinterpret_cast<GrBackendContext>(vkBackend.get());
// There is some bug (either in Skia or the NV Vulkan driver) where VkDevice
// destruction will hang occaisonally. For some reason having an existing GL
// context fixes this.
if (!fSentinelGLContext) {
fSentinelGLContext.reset(CreatePlatformGLTestContext(kGL_GrGLStandard));
if (!fSentinelGLContext) {
fSentinelGLContext.reset(CreatePlatformGLTestContext(kGLES_GrGLStandard));
}
}
break;
#endif
default:
return ContextInfo();
}
grCtx.reset(GrContext::Create(backend, backendContext, fGlobalOptions));
if (!grCtx.get()) {
return ContextInfo();
}
if (kEnableNVPR_ContextOptions & options) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
return ContextInfo();
}
}
if (kRequireSRGBSupport_ContextOptions & options) {
if (!grCtx->caps()->srgbSupport()) {
return ContextInfo();
}
}
Context& context = fContexts.push_back();
context.fGLContext = glCtx.release();
context.fGrContext = SkRef(grCtx.get());
context.fType = type;
context.fOptions = options;
context.fAbandoned = false;
return ContextInfo(context.fGrContext, context.fGLContext);
}
GrContext* GrContextFactory::get(GLContextType type, GrGLStandard forcedGpuAPI) {
for (int i = 0; i < fContexts.count(); ++i) {
if (forcedGpuAPI != kNone_GrGLStandard &&
forcedGpuAPI != fContexts[i].fGLContext->gl()->fStandard)
continue;
if (fContexts[i].fType == type) {
fContexts[i].fGLContext->makeCurrent();
return fContexts[i].fGrContext;
}
}
SkAutoTUnref<SkGLContext> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
case kNVPR_GLContextType: // fallthru
case kNative_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(forcedGpuAPI));
break;
#ifdef SK_ANGLE
case kANGLE_GLContextType:
glCtx.reset(SkANGLEGLContext::Create(forcedGpuAPI));
break;
#endif
#ifdef SK_MESA
case kMESA_GLContextType:
glCtx.reset(SkMesaGLContext::Create(forcedGpuAPI));
break;
#endif
case kNull_GLContextType:
glCtx.reset(SkNullGLContext::Create(forcedGpuAPI));
break;
case kDebug_GLContextType:
glCtx.reset(SkDebugGLContext::Create(forcedGpuAPI));
break;
}
if (NULL == glCtx.get()) {
return NULL;
}
SkASSERT(glCtx->isValid());
// Ensure NVPR is available for the NVPR type and block it from other types.
SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx->gl()));
if (kNVPR_GLContextType == type) {
if (!glInterface->hasExtension("GL_NV_path_rendering")) {
return NULL;
}
} else {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface));
if (!glInterface) {
return NULL;
}
}
glCtx->makeCurrent();
GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glInterface.get());
grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx, &fGlobalOptions));
if (!grCtx.get()) {
return NULL;
}
GPUContext& ctx = fContexts.push_back();
ctx.fGLContext = glCtx.get();
ctx.fGLContext->ref();
ctx.fGrContext = grCtx.get();
ctx.fGrContext->ref();
ctx.fType = type;
return ctx.fGrContext;
}
GrContext* GrContextFactory::get(GLContextType type, GrGLStandard forcedGpuAPI) {
for (int i = 0; i < fContexts.count(); ++i) {
if (forcedGpuAPI != kNone_GrGLStandard &&
forcedGpuAPI != fContexts[i].fGLContext->gl()->fStandard)
continue;
if (fContexts[i].fType == type) {
fContexts[i].fGLContext->makeCurrent();
return fContexts[i].fGrContext;
}
}
SkAutoTUnref<SkGLContext> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
case kNVPR_GLContextType: // fallthru
case kNative_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(forcedGpuAPI));
break;
#ifdef SK_ANGLE
case kANGLE_GLContextType:
glCtx.reset(SkANGLEGLContext::Create(forcedGpuAPI));
break;
#endif
#ifdef SK_MESA
case kMESA_GLContextType:
glCtx.reset(SkMesaGLContext::Create(forcedGpuAPI));
break;
#endif
case kNull_GLContextType:
glCtx.reset(SkNullGLContext::Create(forcedGpuAPI));
break;
case kDebug_GLContextType:
glCtx.reset(SkDebugGLContext::Create(forcedGpuAPI));
break;
}
if (NULL == glCtx.get()) {
return NULL;
}
SkASSERT(glCtx->isValid());
// Block NVPR from non-NVPR types.
SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx->gl()));
if (kNVPR_GLContextType != type) {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface));
if (!glInterface) {
return NULL;
}
} else {
if (!glInterface->hasExtension("GL_NV_path_rendering")) {
return NULL;
}
}
glCtx->makeCurrent();
GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glInterface.get());
#ifdef SK_VULKAN
grCtx.reset(GrContext::Create(kVulkan_GrBackend, p3dctx, fGlobalOptions));
#else
grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx, fGlobalOptions));
#endif
if (!grCtx.get()) {
return NULL;
}
// Warn if path rendering support is not available for the NVPR type.
if (kNVPR_GLContextType == type) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
GrGpu* gpu = grCtx->getGpu();
const GrGLContext* ctx = gpu->glContextForTesting();
if (ctx) {
const GrGLubyte* verUByte;
GR_GL_CALL_RET(ctx->interface(), verUByte, GetString(GR_GL_VERSION));
const char* ver = reinterpret_cast<const char*>(verUByte);
SkDebugf("\nWARNING: nvprmsaa config requested, but driver path rendering "
"support not available. Maybe update the driver? Your driver version "
"string: \"%s\"\n", ver);
} else {
SkDebugf("\nWARNING: nvprmsaa config requested, but driver path rendering "
"support not available.\n");
}
}
}
GPUContext& ctx = fContexts.push_back();
ctx.fGLContext = glCtx.get();
ctx.fGLContext->ref();
ctx.fGrContext = grCtx.get();
ctx.fGrContext->ref();
ctx.fType = type;
return ctx.fGrContext;
}
ContextInfo GrContextFactory::getContextInfo(ContextType type, ContextOptions options) {
for (int i = 0; i < fContexts.count(); ++i) {
Context& context = fContexts[i];
if (context.fType == type &&
context.fOptions == options &&
!context.fAbandoned) {
context.fTestContext->makeCurrent();
return ContextInfo(context.fBackend, context.fTestContext, context.fGrContext);
}
}
SkAutoTDelete<TestContext> testCtx;
sk_sp<GrContext> grCtx;
GrBackendContext backendContext = 0;
sk_sp<const GrGLInterface> glInterface;
GrBackend backend = ContextTypeBackend(type);
switch (backend) {
case kOpenGL_GrBackend: {
GLTestContext* glCtx;
switch (type) {
case kGL_ContextType:
glCtx = CreatePlatformGLTestContext(kGL_GrGLStandard);
break;
case kGLES_ContextType:
glCtx = CreatePlatformGLTestContext(kGLES_GrGLStandard);
break;
#if SK_ANGLE
# ifdef SK_BUILD_FOR_WIN
case kANGLE_ContextType:
glCtx = CreateANGLEDirect3DGLTestContext();
break;
# endif
case kANGLE_GL_ContextType:
glCtx = CreateANGLEOpenGLGLTestContext();
break;
#endif
#if SK_COMMAND_BUFFER
case kCommandBuffer_ContextType:
glCtx = CommandBufferGLTestContext::Create();
break;
#endif
#if SK_MESA
case kMESA_ContextType:
glCtx = CreateMesaGLTestContext();
break;
#endif
case kNullGL_ContextType:
glCtx = CreateNullGLTestContext(kEnableNVPR_ContextOptions & options);
break;
case kDebugGL_ContextType:
glCtx = CreateDebugGLTestContext();
break;
default:
return ContextInfo();
}
if (!glCtx) {
return ContextInfo();
}
testCtx.reset(glCtx);
glInterface.reset(SkRef(glCtx->gl()));
// Block NVPR from non-NVPR types. We don't block NVPR from contexts that will use
// instanced rendering because that would prevent us from testing mixed samples.
if (!((kEnableNVPR_ContextOptions | kUseInstanced_ContextOptions) & options)) {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface.get()));
if (!glInterface) {
return ContextInfo();
}
}
backendContext = reinterpret_cast<GrBackendContext>(glInterface.get());
break;
}
#ifdef SK_VULKAN
case kVulkan_GrBackend:
SkASSERT(kVulkan_ContextType == type);
if (kEnableNVPR_ContextOptions & options) {
return ContextInfo();
}
testCtx.reset(CreatePlatformVkTestContext());
if (!testCtx) {
return ContextInfo();
}
// There is some bug (either in Skia or the NV Vulkan driver) where VkDevice
// destruction will hang occaisonally. For some reason having an existing GL
// context fixes this.
if (!fSentinelGLContext) {
fSentinelGLContext.reset(CreatePlatformGLTestContext(kGL_GrGLStandard));
if (!fSentinelGLContext) {
fSentinelGLContext.reset(CreatePlatformGLTestContext(kGLES_GrGLStandard));
}
}
backendContext = testCtx->backendContext();
break;
#endif
default:
return ContextInfo();
}
testCtx->makeCurrent();
SkASSERT(testCtx && testCtx->backend() == backend);
GrContextOptions grOptions = fGlobalOptions;
if (kUseInstanced_ContextOptions & options) {
grOptions.fEnableInstancedRendering = true;
}
grCtx.reset(GrContext::Create(backend, backendContext, grOptions));
if (!grCtx.get()) {
return ContextInfo();
}
if (kEnableNVPR_ContextOptions & options) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
return ContextInfo();
}
}
if (kUseInstanced_ContextOptions & options) {
if (GrCaps::InstancedSupport::kNone == grCtx->caps()->instancedSupport()) {
return ContextInfo();
}
}
if (kRequireSRGBSupport_ContextOptions & options) {
if (!grCtx->caps()->srgbSupport()) {
return ContextInfo();
}
}
Context& context = fContexts.push_back();
context.fBackend = backend;
context.fTestContext = testCtx.release();
context.fGrContext = SkRef(grCtx.get());
context.fType = type;
context.fOptions = options;
context.fAbandoned = false;
return ContextInfo(context.fBackend, context.fTestContext, context.fGrContext);
}
GrContextFactory::ContextInfo* GrContextFactory::getContextInfo(GLContextType type,
GLContextOptions options) {
for (int i = 0; i < fContexts.count(); ++i) {
if (fContexts[i]->fType == type &&
fContexts[i]->fOptions == options) {
fContexts[i]->fGLContext->makeCurrent();
return fContexts[i];
}
}
SkAutoTUnref<SkGLContext> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
case kNative_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(kNone_GrGLStandard));
break;
case kGL_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(kGL_GrGLStandard));
break;
case kGLES_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(kGLES_GrGLStandard));
break;
#if SK_ANGLE
#ifdef SK_BUILD_FOR_WIN
case kANGLE_GLContextType:
glCtx.reset(SkANGLEGLContext::CreateDirectX());
break;
#endif
case kANGLE_GL_GLContextType:
glCtx.reset(SkANGLEGLContext::CreateOpenGL());
break;
#endif
#if SK_COMMAND_BUFFER
case kCommandBuffer_GLContextType:
glCtx.reset(SkCommandBufferGLContext::Create());
break;
#endif
#if SK_MESA
case kMESA_GLContextType:
glCtx.reset(SkMesaGLContext::Create());
break;
#endif
case kNull_GLContextType:
glCtx.reset(SkNullGLContext::Create());
break;
case kDebug_GLContextType:
glCtx.reset(SkDebugGLContext::Create());
break;
}
if (nullptr == glCtx.get()) {
return nullptr;
}
SkASSERT(glCtx->isValid());
// Block NVPR from non-NVPR types.
SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx->gl()));
if (!(kEnableNVPR_GLContextOptions & options)) {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface));
if (!glInterface) {
return nullptr;
}
}
glCtx->makeCurrent();
GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glInterface.get());
#ifdef SK_VULKAN
grCtx.reset(GrContext::Create(kVulkan_GrBackend, p3dctx, fGlobalOptions));
#else
grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx, fGlobalOptions));
#endif
if (!grCtx.get()) {
return nullptr;
}
if (kEnableNVPR_GLContextOptions & options) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
return nullptr;
}
}
ContextInfo* ctx = fContexts.emplace_back(new ContextInfo);
ctx->fGLContext = SkRef(glCtx.get());
ctx->fGrContext = SkRef(grCtx.get());
ctx->fType = type;
ctx->fOptions = options;
return ctx;
}
