blob: f09bad932b8aa75b8d43fb6b6a47a5a4f50c1206 (
plain)
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/*
* 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
#if SK_ANGLE
#include "gl/SkANGLEGLContext.h"
#endif
#include "gl/SkDebugGLContext.h"
#if SK_MESA
#include "gl/SkMesaGLContext.h"
#endif
#include "gl/SkNativeGLContext.h"
#include "gl/SkNullGLContext.h"
#include "GrContext.h"
#include "SkTArray.h"
/**
* 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:
/**
* Types of GL contexts supported. For historical and testing reasons the native GrContext will
* not use "GL_NV_path_rendering" even when the driver supports it. There is a separate context
* type that does not remove NVPR support and which will fail when the driver does not support
* the extension.
*/
enum GLContextType {
kNative_GLContextType,
#if SK_ANGLE
kANGLE_GLContextType,
#endif
#if SK_MESA
kMESA_GLContextType,
#endif
/** Similar to kNative but does not filter NVPR. It will fail if the GL driver does not
support NVPR */
kNVPR_GLContextType,
kNull_GLContextType,
kDebug_GLContextType,
kLastGLContextType = kDebug_GLContextType
};
static const int kGLContextTypeCnt = kLastGLContextType + 1;
static bool IsRenderingGLContext(GLContextType type) {
switch (type) {
case kNull_GLContextType:
case kDebug_GLContextType:
return false;
default:
return true;
}
}
static const char* GLContextTypeName(GLContextType type) {
switch (type) {
case kNative_GLContextType:
return "native";
case kNull_GLContextType:
return "null";
#if SK_ANGLE
case kANGLE_GLContextType:
return "angle";
#endif
#if SK_MESA
case kMESA_GLContextType:
return "mesa";
#endif
case kNVPR_GLContextType:
return "nvpr";
case kDebug_GLContextType:
return "debug";
default:
SkFAIL("Unknown GL Context type.");
}
}
GrContextFactory() {
}
~GrContextFactory() { this->destroyContexts(); }
void destroyContexts() {
for (int i = 0; i < fContexts.count(); ++i) {
fContexts[i].fGLContext->makeCurrent();
fContexts[i].fGrContext->unref();
fContexts[i].fGLContext->unref();
}
fContexts.reset();
}
/**
* Get a GrContext initialized with a type of GL context. It also makes the GL context current.
*/
GrContext* get(GLContextType type) {
for (int i = 0; i < fContexts.count(); ++i) {
if (fContexts[i].fType == type) {
fContexts[i].fGLContext->makeCurrent();
return fContexts[i].fGrContext;
}
}
SkAutoTUnref<SkGLContextHelper> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
case kNVPR_GLContextType: // fallthru
case kNative_GLContextType:
glCtx.reset(SkNEW(SkNativeGLContext));
break;
#ifdef SK_ANGLE
case kANGLE_GLContextType:
glCtx.reset(SkNEW(SkANGLEGLContext));
break;
#endif
#ifdef SK_MESA
case kMESA_GLContextType:
glCtx.reset(SkNEW(SkMesaGLContext));
break;
#endif
case kNull_GLContextType:
glCtx.reset(SkNEW(SkNullGLContext));
break;
case kDebug_GLContextType:
glCtx.reset(SkNEW(SkDebugGLContext));
break;
}
static const int kBogusSize = 1;
if (!glCtx.get()) {
return NULL;
}
if (!glCtx.get()->init(kBogusSize, kBogusSize)) {
return NULL;
}
// Ensure NVPR is available for the NVPR type and block it from other types.
SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx.get()->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));
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;
}
// Returns the GLContext of the given type. If it has not been created yet,
// NULL is returned instead.
SkGLContextHelper* getGLContext(GLContextType type) {
for (int i = 0; i < fContexts.count(); ++i) {
if (fContexts[i].fType == type) {
return fContexts[i].fGLContext;
}
}
return NULL;
}
private:
struct GPUContext {
GLContextType fType;
SkGLContextHelper* fGLContext;
GrContext* fGrContext;
};
SkTArray<GPUContext, true> fContexts;
};
#endif
|
