OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2012 Google Inc. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license that can be | |
5 * found in the LICENSE file. | |
6 */ | |
7 | |
8 #include "gl/angle/SkANGLEGLContext.h" | |
9 | |
10 #include <EGL/egl.h> | |
11 #include <EGL/eglext.h> | |
12 | |
13 #include "gl/GrGLDefines.h" | |
14 #include "gl/GrGLUtil.h" | |
15 | |
16 #define EGL_PLATFORM_ANGLE_ANGLE 0x3202 | |
17 #define EGL_PLATFORM_ANGLE_TYPE_ANGLE 0x3203 | |
18 #define EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE 0x3207 | |
19 #define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE 0x3208 | |
20 #define EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE 0x320D | |
21 | |
22 void* SkANGLEGLContext::GetD3DEGLDisplay(void* nativeDisplay, bool useGLBackend)
{ | |
23 PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT; | |
24 eglGetPlatformDisplayEXT = | |
25 (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDispla
yEXT"); | |
26 | |
27 if (!eglGetPlatformDisplayEXT) { | |
28 return eglGetDisplay(static_cast<EGLNativeDisplayType>(nativeDisplay)); | |
29 } | |
30 | |
31 EGLDisplay display = EGL_NO_DISPLAY; | |
32 if (useGLBackend) { | |
33 // Try for an ANGLE D3D11 context, fall back to D3D9. | |
34 EGLint attribs[3] = { | |
35 EGL_PLATFORM_ANGLE_TYPE_ANGLE, | |
36 EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE, | |
37 EGL_NONE | |
38 }; | |
39 display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, nativeDispl
ay, attribs); | |
40 } else { | |
41 // Try for an ANGLE D3D11 context, fall back to D3D9, and finally GL. | |
42 EGLint attribs[3][3] = { | |
43 { | |
44 EGL_PLATFORM_ANGLE_TYPE_ANGLE, | |
45 EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, | |
46 EGL_NONE | |
47 }, | |
48 { | |
49 EGL_PLATFORM_ANGLE_TYPE_ANGLE, | |
50 EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE, | |
51 EGL_NONE | |
52 }, | |
53 { | |
54 EGL_PLATFORM_ANGLE_TYPE_ANGLE, | |
55 EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE, | |
56 EGL_NONE | |
57 } | |
58 }; | |
59 for (int i = 0; i < 3 && display == EGL_NO_DISPLAY; ++i) { | |
60 display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,nativeDi
splay, attribs[i]); | |
61 } | |
62 } | |
63 return display; | |
64 } | |
65 | |
66 SkANGLEGLContext::SkANGLEGLContext(bool useGLBackend) | |
67 : fContext(EGL_NO_CONTEXT) | |
68 , fDisplay(EGL_NO_DISPLAY) | |
69 , fSurface(EGL_NO_SURFACE) { | |
70 | |
71 EGLint numConfigs; | |
72 static const EGLint configAttribs[] = { | |
73 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, | |
74 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, | |
75 EGL_RED_SIZE, 8, | |
76 EGL_GREEN_SIZE, 8, | |
77 EGL_BLUE_SIZE, 8, | |
78 EGL_ALPHA_SIZE, 8, | |
79 EGL_NONE | |
80 }; | |
81 | |
82 fIsGLBackend = useGLBackend; | |
83 fDisplay = GetD3DEGLDisplay(EGL_DEFAULT_DISPLAY, useGLBackend); | |
84 if (EGL_NO_DISPLAY == fDisplay) { | |
85 SkDebugf("Could not create EGL display!"); | |
86 return; | |
87 } | |
88 | |
89 EGLint majorVersion; | |
90 EGLint minorVersion; | |
91 eglInitialize(fDisplay, &majorVersion, &minorVersion); | |
92 | |
93 EGLConfig surfaceConfig; | |
94 eglChooseConfig(fDisplay, configAttribs, &surfaceConfig, 1, &numConfigs); | |
95 | |
96 static const EGLint contextAttribs[] = { | |
97 EGL_CONTEXT_CLIENT_VERSION, 2, | |
98 EGL_NONE | |
99 }; | |
100 fContext = eglCreateContext(fDisplay, surfaceConfig, nullptr, contextAttribs
); | |
101 | |
102 | |
103 static const EGLint surfaceAttribs[] = { | |
104 EGL_WIDTH, 1, | |
105 EGL_HEIGHT, 1, | |
106 EGL_NONE | |
107 }; | |
108 | |
109 fSurface = eglCreatePbufferSurface(fDisplay, surfaceConfig, surfaceAttribs); | |
110 | |
111 eglMakeCurrent(fDisplay, fSurface, fSurface, fContext); | |
112 | |
113 SkAutoTUnref<const GrGLInterface> gl(GrGLCreateANGLEInterface()); | |
114 if (nullptr == gl.get()) { | |
115 SkDebugf("Could not create ANGLE GL interface!\n"); | |
116 this->destroyGLContext(); | |
117 return; | |
118 } | |
119 if (!gl->validate()) { | |
120 SkDebugf("Could not validate ANGLE GL interface!\n"); | |
121 this->destroyGLContext(); | |
122 return; | |
123 } | |
124 | |
125 this->init(gl.release()); | |
126 } | |
127 | |
128 SkANGLEGLContext::~SkANGLEGLContext() { | |
129 this->teardown(); | |
130 this->destroyGLContext(); | |
131 } | |
132 | |
133 GrEGLImage SkANGLEGLContext::texture2DToEGLImage(GrGLuint texID) const { | |
134 if (!this->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) { | |
135 return GR_EGL_NO_IMAGE; | |
136 } | |
137 GrEGLImage img; | |
138 GrEGLint attribs[] = { GR_EGL_GL_TEXTURE_LEVEL, 0, | |
139 GR_EGL_IMAGE_PRESERVED, GR_EGL_TRUE, | |
140 GR_EGL_NONE }; | |
141 // 64 bit cast is to shut Visual C++ up about casting 32 bit value to a poin
ter. | |
142 GrEGLClientBuffer clientBuffer = reinterpret_cast<GrEGLClientBuffer>((uint64
_t)texID); | |
143 GR_GL_CALL_RET(this->gl(), img, | |
144 EGLCreateImage(fDisplay, fContext, GR_EGL_GL_TEXTURE_2D, clie
ntBuffer, | |
145 attribs)); | |
146 return img; | |
147 } | |
148 | |
149 void SkANGLEGLContext::destroyEGLImage(GrEGLImage image) const { | |
150 GR_GL_CALL(this->gl(), EGLDestroyImage(fDisplay, image)); | |
151 } | |
152 | |
153 GrGLuint SkANGLEGLContext::eglImageToExternalTexture(GrEGLImage image) const { | |
154 GrGLClearErr(this->gl()); | |
155 if (!this->gl()->hasExtension("GL_OES_EGL_image_external")) { | |
156 return 0; | |
157 } | |
158 typedef GrGLvoid (*EGLImageTargetTexture2DProc)(GrGLenum, GrGLeglImage); | |
159 | |
160 EGLImageTargetTexture2DProc glEGLImageTargetTexture2D = | |
161 (EGLImageTargetTexture2DProc)eglGetProcAddress("glEGLImageTargetTexture2
DOES"); | |
162 if (!glEGLImageTargetTexture2D) { | |
163 return 0; | |
164 } | |
165 GrGLuint texID; | |
166 GR_GL_CALL(this->gl(), GenTextures(1, &texID)); | |
167 if (!texID) { | |
168 return 0; | |
169 } | |
170 GR_GL_CALL(this->gl(), BindTexture(GR_GL_TEXTURE_EXTERNAL, texID)); | |
171 if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) { | |
172 GR_GL_CALL(this->gl(), DeleteTextures(1, &texID)); | |
173 return 0; | |
174 } | |
175 glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image); | |
176 if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) { | |
177 GR_GL_CALL(this->gl(), DeleteTextures(1, &texID)); | |
178 return 0; | |
179 } | |
180 return texID; | |
181 } | |
182 | |
183 SkGLContext* SkANGLEGLContext::createNew() const { | |
184 #ifdef SK_BUILD_FOR_WIN | |
185 SkGLContext* ctx = fIsGLBackend ? SkANGLEGLContext::CreateOpenGL() | |
186 : SkANGLEGLContext::CreateDirectX(); | |
187 #else | |
188 SkGLContext* ctx = SkANGLEGLContext::CreateOpenGL(); | |
189 #endif | |
190 if (ctx) { | |
191 ctx->makeCurrent(); | |
192 } | |
193 return ctx; | |
194 } | |
195 | |
196 void SkANGLEGLContext::destroyGLContext() { | |
197 if (fDisplay) { | |
198 eglMakeCurrent(fDisplay, 0, 0, 0); | |
199 | |
200 if (fContext) { | |
201 eglDestroyContext(fDisplay, fContext); | |
202 fContext = EGL_NO_CONTEXT; | |
203 } | |
204 | |
205 if (fSurface) { | |
206 eglDestroySurface(fDisplay, fSurface); | |
207 fSurface = EGL_NO_SURFACE; | |
208 } | |
209 | |
210 //TODO should we close the display? | |
211 fDisplay = EGL_NO_DISPLAY; | |
212 } | |
213 } | |
214 | |
215 void SkANGLEGLContext::onPlatformMakeCurrent() const { | |
216 if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) { | |
217 SkDebugf("Could not set the context.\n"); | |
218 } | |
219 } | |
220 | |
221 void SkANGLEGLContext::onPlatformSwapBuffers() const { | |
222 if (!eglSwapBuffers(fDisplay, fSurface)) { | |
223 SkDebugf("Could not complete eglSwapBuffers.\n"); | |
224 } | |
225 } | |
226 | |
227 GrGLFuncPtr SkANGLEGLContext::onPlatformGetProcAddress(const char* name) const { | |
228 return eglGetProcAddress(name); | |
229 } | |
OLD | NEW |