AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
bc096bffcb
skia2/tools/gpu/GrContextFactory.cpp
Brian Salomon 6405e71279 Remove gpu configs that don't have explicit API. 
DOCS_PREVIEW= https://skia.org/?cl=9871

Change-Id: I510473cf91d8bee38d1e33424b1ae7b30dc86968
Reviewed-on: https://skia-review.googlesource.com/9871
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
2017-03-20 13:31:49 +00:00

282 lines
10 KiB
C++
Raw Blame History

/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrContextFactory.h"
#include "gl/GLTestContext.h"
#if SK_ANGLE
#include "gl/angle/GLTestContext_angle.h"
#endif
#include "gl/command_buffer/GLTestContext_command_buffer.h"
#include "gl/debug/DebugGLTestContext.h"
#if SK_MESA
#include "gl/mesa/GLTestContext_mesa.h"
#endif
#ifdef SK_VULKAN
#include "vk/VkTestContext.h"
#endif
#include "gl/null/NullGLTestContext.h"
#include "gl/GrGLGpu.h"
#include "GrCaps.h"
#if defined(SK_BUILD_FOR_WIN32) && defined(SK_ENABLE_DISCRETE_GPU)
extern "C" {
// NVIDIA documents that the presence and value of this symbol programmatically enable the high
// performance GPU in laptops with switchable graphics.
// https://docs.nvidia.com/gameworks/content/technologies/desktop/optimus.htm
// From testing, including this symbol, even if it is set to 0, we still get the NVIDIA GPU.
_declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
// AMD has a similar mechanism, although I don't have an AMD laptop, so this is untested.
// https://community.amd.com/thread/169965
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
}
#endif
namespace sk_gpu_test {
GrContextFactory::GrContextFactory() { }
GrContextFactory::GrContextFactory(const GrContextOptions& opts)
: fGlobalOptions(opts) {
}
GrContextFactory::~GrContextFactory() {
this->destroyContexts();
}
void GrContextFactory::destroyContexts() {
for (Context& context : fContexts) {
if (context.fTestContext) {
context.fTestContext->makeCurrent();
}
if (!context.fGrContext->unique()) {
context.fGrContext->releaseResourcesAndAbandonContext();
context.fAbandoned = true;
}
context.fGrContext->unref();
delete context.fTestContext;
}
fContexts.reset();
}
void GrContextFactory::abandonContexts() {
for (Context& context : fContexts) {
if (!context.fAbandoned) {
if (context.fTestContext) {
context.fTestContext->makeCurrent();
context.fTestContext->testAbandon();
delete(context.fTestContext);
context.fTestContext = nullptr;
}
context.fGrContext->abandonContext();
context.fAbandoned = true;
}
}
}
void GrContextFactory::releaseResourcesAndAbandonContexts() {
for (Context& context : fContexts) {
if (!context.fAbandoned) {
if (context.fTestContext) {
context.fTestContext->makeCurrent();
}
context.fGrContext->releaseResourcesAndAbandonContext();
context.fAbandoned = true;
if (context.fTestContext) {
delete context.fTestContext;
context.fTestContext = nullptr;
}
}
}
}
ContextInfo GrContextFactory::getContextInfoInternal(ContextType type, ContextOverrides overrides,
GrContext* shareContext, uint32_t shareIndex) {
// (shareIndex != 0) -> (shareContext != nullptr)
SkASSERT((shareIndex == 0) || (shareContext != nullptr));
for (int i = 0; i < fContexts.count(); ++i) {
Context& context = fContexts[i];
if (context.fType == type &&
context.fOverrides == overrides &&
context.fShareContext == shareContext &&
context.fShareIndex == shareIndex &&
!context.fAbandoned) {
context.fTestContext->makeCurrent();
return ContextInfo(context.fBackend, context.fTestContext, context.fGrContext);
}
}
// If we're trying to create a context in a share group, find the master context
Context* masterContext = nullptr;
if (shareContext) {
for (int i = 0; i < fContexts.count(); ++i) {
if (!fContexts[i].fAbandoned && fContexts[i].fGrContext == shareContext) {
masterContext = &fContexts[i];
break;
}
}
SkASSERT(masterContext && masterContext->fType == type);
}
std::unique_ptr<TestContext> testCtx;
GrBackendContext backendContext = 0;
sk_sp<const GrGLInterface> glInterface;
GrBackend backend = ContextTypeBackend(type);
switch (backend) {
case kOpenGL_GrBackend: {
GLTestContext* glShareContext = masterContext
? static_cast<GLTestContext*>(masterContext->fTestContext) : nullptr;
GLTestContext* glCtx;
switch (type) {
case kGL_ContextType:
glCtx = CreatePlatformGLTestContext(kGL_GrGLStandard, glShareContext);
break;
case kGLES_ContextType:
glCtx = CreatePlatformGLTestContext(kGLES_GrGLStandard, glShareContext);
break;
#if SK_ANGLE
case kANGLE_D3D9_ES2_ContextType:
glCtx = MakeANGLETestContext(ANGLEBackend::kD3D9, ANGLEContextVersion::kES2,
glShareContext).release();
break;
case kANGLE_D3D11_ES2_ContextType:
glCtx = MakeANGLETestContext(ANGLEBackend::kD3D11, ANGLEContextVersion::kES2,
glShareContext).release();
break;
case kANGLE_D3D11_ES3_ContextType:
glCtx = MakeANGLETestContext(ANGLEBackend::kD3D11, ANGLEContextVersion::kES3,
glShareContext).release();
break;
case kANGLE_GL_ES2_ContextType:
glCtx = MakeANGLETestContext(ANGLEBackend::kOpenGL, ANGLEContextVersion::kES2,
glShareContext).release();
break;
case kANGLE_GL_ES3_ContextType:
glCtx = MakeANGLETestContext(ANGLEBackend::kOpenGL, ANGLEContextVersion::kES3,
glShareContext).release();
break;
#endif
case kCommandBuffer_ContextType:
glCtx = CommandBufferGLTestContext::Create(glShareContext);
break;
#if SK_MESA
case kMESA_ContextType:
glCtx = CreateMesaGLTestContext(glShareContext);
break;
#endif
case kNullGL_ContextType:
glCtx = CreateNullGLTestContext(
ContextOverrides::kRequireNVPRSupport & overrides, glShareContext);
break;
case kDebugGL_ContextType:
glCtx = CreateDebugGLTestContext(glShareContext);
break;
default:
return ContextInfo();
}
if (!glCtx) {
return ContextInfo();
}
testCtx.reset(glCtx);
glInterface.reset(SkRef(glCtx->gl()));
backendContext = reinterpret_cast<GrBackendContext>(glInterface.get());
break;
}
#ifdef SK_VULKAN
case kVulkan_GrBackend:
if (masterContext) {
// Shared contexts not supported yet
return ContextInfo();
}
SkASSERT(kVulkan_ContextType == type);
if (ContextOverrides::kRequireNVPRSupport & overrides) {
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 (ContextOverrides::kDisableNVPR & overrides) {
grOptions.fSuppressPathRendering = true;
}
if (ContextOverrides::kUseInstanced & overrides) {
grOptions.fEnableInstancedRendering = true;
}
if (ContextOverrides::kAllowSRGBWithoutDecodeControl & overrides) {
grOptions.fRequireDecodeDisableForSRGB = false;
}
sk_sp<GrContext> grCtx(GrContext::Create(backend, backendContext, grOptions));
if (!grCtx.get()) {
return ContextInfo();
}
if (ContextOverrides::kRequireNVPRSupport & overrides) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
return ContextInfo();
}
}
if (ContextOverrides::kUseInstanced & overrides) {
if (GrCaps::InstancedSupport::kNone == grCtx->caps()->instancedSupport()) {
return ContextInfo();
}
}
if (ContextOverrides::kRequireSRGBSupport & overrides) {
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.fOverrides = overrides;
context.fAbandoned = false;
context.fShareContext = shareContext;
context.fShareIndex = shareIndex;
return ContextInfo(context.fBackend, context.fTestContext, context.fGrContext);
}
ContextInfo GrContextFactory::getContextInfo(ContextType type, ContextOverrides overrides) {
return this->getContextInfoInternal(type, overrides, nullptr, 0);
}
ContextInfo GrContextFactory::getSharedContextInfo(GrContext* shareContext, uint32_t shareIndex) {
SkASSERT(shareContext);
for (int i = 0; i < fContexts.count(); ++i) {
if (!fContexts[i].fAbandoned && fContexts[i].fGrContext == shareContext) {
return this->getContextInfoInternal(fContexts[i].fType, fContexts[i].fOverrides,
shareContext, shareIndex);
}
}
return ContextInfo();
}
} // namespace sk_gpu_test
Reference in New Issue View Git Blame Copy Permalink