OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #ifndef GrContextFactory_DEFINED | 8 #ifndef GrContextFactory_DEFINED |
9 #define GrContextFactory_DEFINED | 9 #define GrContextFactory_DEFINED |
10 | 10 |
11 #if SK_ANGLE | 11 #if SK_ANGLE |
12 #include "gl/SkANGLEGLContext.h" | 12 #include "gl/SkANGLEGLContext.h" |
13 #endif | 13 #endif |
14 #include "gl/SkDebugGLContext.h" | 14 #include "gl/SkDebugGLContext.h" |
15 #if SK_MESA | 15 #if SK_MESA |
16 #include "gl/SkMesaGLContext.h" | 16 #include "gl/SkMesaGLContext.h" |
17 #endif | 17 #endif |
18 #include "gl/SkNativeGLContext.h" | 18 #include "gl/SkNativeGLContext.h" |
19 #include "gl/SkNullGLContext.h" | 19 #include "gl/SkNullGLContext.h" |
20 | 20 |
21 #include "GrContext.h" | 21 #include "GrContext.h" |
22 #include "SkTArray.h" | 22 #include "SkTArray.h" |
23 | 23 |
24 /** | 24 /** |
25 * This is a simple class that is useful in test apps that use different | 25 * This is a simple class that is useful in test apps that use different |
26 * GrContexts backed by different types of GL contexts. It manages creating the | 26 * GrContexts backed by different types of GL contexts. It manages creating the |
27 * GL context and a GrContext that uses it. The GL/Gr contexts persist until the | 27 * GL context and a GrContext that uses it. The GL/Gr contexts persist until the |
28 * factory is destroyed (though the caller can always grab a ref on the returned | 28 * factory is destroyed (though the caller can always grab a ref on the returned |
29 * Gr and GL contexts to make them outlive the factory). | 29 * GrContext to make it outlive the factory). |
30 */ | 30 */ |
31 class GrContextFactory : public SkNoncopyable { | 31 class GrContextFactory : public SkNoncopyable { |
32 public: | 32 public: |
33 /** | 33 /** |
34 * Types of GL contexts supported. For historical and testing reasons the na
tive GrContext will | 34 * Types of GL contexts supported. |
35 * not use "GL_NV_path_rendering" even when the driver supports it. There is
a separate context | |
36 * type that does not remove NVPR support and which will fail when the drive
r does not support | |
37 * the extension. | |
38 */ | 35 */ |
39 enum GLContextType { | 36 enum GLContextType { |
40 kNative_GLContextType, | 37 kNative_GLContextType, |
41 #if SK_ANGLE | 38 #if SK_ANGLE |
42 kANGLE_GLContextType, | 39 kANGLE_GLContextType, |
43 #endif | 40 #endif |
44 #if SK_MESA | 41 #if SK_MESA |
45 kMESA_GLContextType, | 42 kMESA_GLContextType, |
46 #endif | 43 #endif |
47 /** Similar to kNative but does not filter NVPR. It will fail if the GL dr
iver does not | |
48 support NVPR */ | |
49 kNVPR_GLContextType, | |
50 kNull_GLContextType, | 44 kNull_GLContextType, |
51 kDebug_GLContextType, | 45 kDebug_GLContextType, |
52 | 46 |
53 kLastGLContextType = kDebug_GLContextType | 47 kLastGLContextType = kDebug_GLContextType |
54 }; | 48 }; |
55 | 49 |
56 static const int kGLContextTypeCnt = kLastGLContextType + 1; | 50 static const int kGLContextTypeCnt = kLastGLContextType + 1; |
57 | 51 |
58 static bool IsRenderingGLContext(GLContextType type) { | 52 static bool IsRenderingGLContext(GLContextType type) { |
59 switch (type) { | 53 switch (type) { |
(...skipping 12 matching lines...) Expand all Loading... |
72 case kNull_GLContextType: | 66 case kNull_GLContextType: |
73 return "null"; | 67 return "null"; |
74 #if SK_ANGLE | 68 #if SK_ANGLE |
75 case kANGLE_GLContextType: | 69 case kANGLE_GLContextType: |
76 return "angle"; | 70 return "angle"; |
77 #endif | 71 #endif |
78 #if SK_MESA | 72 #if SK_MESA |
79 case kMESA_GLContextType: | 73 case kMESA_GLContextType: |
80 return "mesa"; | 74 return "mesa"; |
81 #endif | 75 #endif |
82 case kNVPR_GLContextType: | |
83 return "nvpr"; | |
84 case kDebug_GLContextType: | 76 case kDebug_GLContextType: |
85 return "debug"; | 77 return "debug"; |
86 default: | 78 default: |
87 GrCrash("Unknown GL Context type."); | 79 GrCrash("Unknown GL Context type."); |
88 } | 80 } |
89 } | 81 } |
90 | 82 |
91 GrContextFactory() { | 83 GrContextFactory() { |
92 } | 84 } |
93 | 85 |
94 ~GrContextFactory() { this->destroyContexts(); } | 86 ~GrContextFactory() { this->destroyContexts(); } |
95 | 87 |
96 void destroyContexts() { | 88 void destroyContexts() { |
97 for (int i = 0; i < fContexts.count(); ++i) { | 89 for (int i = 0; i < fContexts.count(); ++i) { |
98 fContexts[i].fGLContext->makeCurrent(); | |
99 fContexts[i].fGrContext->unref(); | 90 fContexts[i].fGrContext->unref(); |
100 fContexts[i].fGLContext->unref(); | 91 fContexts[i].fGLContext->unref(); |
101 } | 92 } |
102 fContexts.reset(); | 93 fContexts.reset(); |
103 } | 94 } |
104 | 95 |
105 /** | 96 /** |
106 * Get a GrContext initialized with a type of GL context. It also makes the
GL context current. | 97 * Get a GrContext initialized with a type of GL context. It also makes the
GL context current. |
107 */ | 98 */ |
108 GrContext* get(GLContextType type) { | 99 GrContext* get(GLContextType type) { |
109 | 100 |
110 for (int i = 0; i < fContexts.count(); ++i) { | 101 for (int i = 0; i < fContexts.count(); ++i) { |
111 if (fContexts[i].fType == type) { | 102 if (fContexts[i].fType == type) { |
112 fContexts[i].fGLContext->makeCurrent(); | 103 fContexts[i].fGLContext->makeCurrent(); |
113 return fContexts[i].fGrContext; | 104 return fContexts[i].fGrContext; |
114 } | 105 } |
115 } | 106 } |
116 SkAutoTUnref<SkGLContextHelper> glCtx; | 107 SkAutoTUnref<SkGLContextHelper> glCtx; |
117 SkAutoTUnref<GrContext> grCtx; | 108 SkAutoTUnref<GrContext> grCtx; |
118 switch (type) { | 109 switch (type) { |
119 case kNVPR_GLContextType: // fallthru | |
120 case kNative_GLContextType: | 110 case kNative_GLContextType: |
121 glCtx.reset(SkNEW(SkNativeGLContext)); | 111 glCtx.reset(SkNEW(SkNativeGLContext)); |
122 break; | 112 break; |
123 #ifdef SK_ANGLE | 113 #ifdef SK_ANGLE |
124 case kANGLE_GLContextType: | 114 case kANGLE_GLContextType: |
125 glCtx.reset(SkNEW(SkANGLEGLContext)); | 115 glCtx.reset(SkNEW(SkANGLEGLContext)); |
126 break; | 116 break; |
127 #endif | 117 #endif |
128 #ifdef SK_MESA | 118 #ifdef SK_MESA |
129 case kMESA_GLContextType: | 119 case kMESA_GLContextType: |
130 glCtx.reset(SkNEW(SkMesaGLContext)); | 120 glCtx.reset(SkNEW(SkMesaGLContext)); |
131 break; | 121 break; |
132 #endif | 122 #endif |
133 case kNull_GLContextType: | 123 case kNull_GLContextType: |
134 glCtx.reset(SkNEW(SkNullGLContext)); | 124 glCtx.reset(SkNEW(SkNullGLContext)); |
135 break; | 125 break; |
136 case kDebug_GLContextType: | 126 case kDebug_GLContextType: |
137 glCtx.reset(SkNEW(SkDebugGLContext)); | 127 glCtx.reset(SkNEW(SkDebugGLContext)); |
138 break; | 128 break; |
139 } | 129 } |
140 static const int kBogusSize = 1; | 130 static const int kBogusSize = 1; |
141 if (!glCtx.get()) { | 131 if (!glCtx.get()) { |
142 return NULL; | 132 return NULL; |
143 } | 133 } |
144 if (!glCtx.get()->init(kBogusSize, kBogusSize)) { | 134 if (!glCtx.get()->init(kBogusSize, kBogusSize)) { |
145 return NULL; | 135 return NULL; |
146 } | 136 } |
147 | 137 GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glCtx.get()
->gl()); |
148 // Ensure NVPR is available for the NVPR type and block it from other ty
pes. | |
149 SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx.get()->gl())); | |
150 if (kNVPR_GLContextType == type) { | |
151 if (!glInterface->hasExtension("GL_NV_path_rendering")) { | |
152 return NULL; | |
153 } | |
154 } else { | |
155 glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface)); | |
156 if (!glInterface) { | |
157 return NULL; | |
158 } | |
159 } | |
160 | |
161 glCtx->makeCurrent(); | |
162 GrBackendContext p3dctx = reinterpret_cast<GrBackendContext>(glInterface
.get()); | |
163 grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx)); | 138 grCtx.reset(GrContext::Create(kOpenGL_GrBackend, p3dctx)); |
164 if (!grCtx.get()) { | 139 if (!grCtx.get()) { |
165 return NULL; | 140 return NULL; |
166 } | 141 } |
167 GPUContext& ctx = fContexts.push_back(); | 142 GPUContext& ctx = fContexts.push_back(); |
168 ctx.fGLContext = glCtx.get(); | 143 ctx.fGLContext = glCtx.get(); |
169 ctx.fGLContext->ref(); | 144 ctx.fGLContext->ref(); |
170 ctx.fGrContext = grCtx.get(); | 145 ctx.fGrContext = grCtx.get(); |
171 ctx.fGrContext->ref(); | 146 ctx.fGrContext->ref(); |
172 ctx.fType = type; | 147 ctx.fType = type; |
(...skipping 15 matching lines...) Expand all Loading... |
188 private: | 163 private: |
189 struct GPUContext { | 164 struct GPUContext { |
190 GLContextType fType; | 165 GLContextType fType; |
191 SkGLContextHelper* fGLContext; | 166 SkGLContextHelper* fGLContext; |
192 GrContext* fGrContext; | 167 GrContext* fGrContext; |
193 }; | 168 }; |
194 SkTArray<GPUContext, true> fContexts; | 169 SkTArray<GPUContext, true> fContexts; |
195 }; | 170 }; |
196 | 171 |
197 #endif | 172 #endif |
OLD | NEW |