1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrContextFactory_DEFINED
#define GrContextFactory_DEFINED
#include "GrContext.h"
#include "GrContextOptions.h"
#include "gl/GLTestContext.h"
#include "vk/VkTestContext.h"
#include "SkTArray.h"
struct GrVkBackendContext;
namespace sk_gpu_test {
class ContextInfo {
public:
ContextInfo() = default;
ContextInfo& operator=(const ContextInfo&) = default;
GrBackend backend() const { return fBackend; }
GrContext* grContext() const { return fGrContext; }
TestContext* testContext() const { return fTestContext; }
GLTestContext* glContext() const {
SkASSERT(kOpenGL_GrBackend == fBackend);
return static_cast<GLTestContext*>(fTestContext);
}
#ifdef SK_VULKAN
VkTestContext* vkContext() const {
SkASSERT(kVulkan_GrBackend == fBackend);
return static_cast<VkTestContext*>(fTestContext);
}
#endif
private:
ContextInfo(GrBackend backend, TestContext* testContext, GrContext* grContext)
: fBackend(backend)
, fTestContext(testContext)
, fGrContext(grContext) {}
GrBackend fBackend = kOpenGL_GrBackend;
// Valid until the factory destroys it via abandonContexts() or destroyContexts().
TestContext* fTestContext = nullptr;
GrContext* fGrContext = nullptr;
friend class GrContextFactory;
};
/**
* This is a simple class that is useful in test apps that use different
* GrContexts backed by different types of GL contexts. It manages creating the
* GL context and a GrContext that uses it. The GL/Gr contexts persist until the
* factory is destroyed (though the caller can always grab a ref on the returned
* Gr and GL contexts to make them outlive the factory).
*/
class GrContextFactory : SkNoncopyable {
public:
// The availability of context types is subject to platform and build configuration
// restrictions.
enum ContextType {
kGL_ContextType, //! OpenGL context.
kGLES_ContextType, //! OpenGL ES context.
kANGLE_D3D9_ES2_ContextType, //! ANGLE on Direct3D9 OpenGL ES 2 context.
kANGLE_D3D11_ES2_ContextType,//! ANGLE on Direct3D11 OpenGL ES 2 context.
kANGLE_D3D11_ES3_ContextType,//! ANGLE on Direct3D11 OpenGL ES 3 context.
kANGLE_GL_ES2_ContextType, //! ANGLE on OpenGL OpenGL ES 2 context.
kANGLE_GL_ES3_ContextType, //! ANGLE on OpenGL OpenGL ES 3 context.
kCommandBuffer_ContextType, //! Chromium command buffer OpenGL ES context.
kMESA_ContextType, //! MESA OpenGL context
kNullGL_ContextType, //! Non-rendering OpenGL mock context.
kDebugGL_ContextType, //! Non-rendering, state verifying OpenGL context.
kVulkan_ContextType, //! Vulkan
kLastContextType = kVulkan_ContextType
};
//! OpenGL or OpenGL ES context depending on the platform. To be removed.
static const ContextType kNativeGL_ContextType;
static const int kContextTypeCnt = kLastContextType + 1;
/**
* Options for GL context creation. For historical and testing reasons the options will default
* to not using GL_NV_path_rendering extension even when the driver supports it.
*/
enum class ContextOptions {
kNone = 0x0,
kEnableNVPR = 0x1,
kUseInstanced = 0x2,
kRequireSRGBSupport = 0x4,
};
static ContextType NativeContextTypeForBackend(GrBackend backend) {
switch (backend) {
case kOpenGL_GrBackend:
return kNativeGL_ContextType;
case kVulkan_GrBackend:
return kVulkan_ContextType;
default:
SkFAIL("Unknown backend");
return kNullGL_ContextType;
}
}
static bool IsRenderingContext(ContextType type) {
switch (type) {
case kNullGL_ContextType:
case kDebugGL_ContextType:
return false;
default:
return true;
}
}
static GrBackend ContextTypeBackend(ContextType type) {
switch (type) {
case kVulkan_ContextType:
return kVulkan_GrBackend;
default:
return kOpenGL_GrBackend;
}
}
explicit GrContextFactory(const GrContextOptions& opts);
GrContextFactory();
~GrContextFactory();
void destroyContexts();
void abandonContexts();
void releaseResourcesAndAbandonContexts();
/**
* Get a context initialized with a type of GL context. It also makes the GL context current.
*/
ContextInfo getContextInfo(ContextType type,
ContextOptions options = ContextOptions::kNone);
/**
* Get a GrContext initialized with a type of GL context. It also makes the GL context current.
*/
GrContext* get(ContextType type, ContextOptions options = ContextOptions::kNone) {
return this->getContextInfo(type, options).grContext();
}
const GrContextOptions& getGlobalOptions() const { return fGlobalOptions; }
private:
struct Context {
ContextType fType;
ContextOptions fOptions;
GrBackend fBackend;
TestContext* fTestContext;
GrContext* fGrContext;
bool fAbandoned;
};
SkTArray<Context, true> fContexts;
SkAutoTDelete<GLTestContext> fSentinelGLContext;
const GrContextOptions fGlobalOptions;
};
} // namespace sk_gpu_test
GR_MAKE_BITFIELD_CLASS_OPS(sk_gpu_test::GrContextFactory::ContextOptions);
#endif
|
