The Tor Browser / file comparison

comparison: gfx/gl/SkiaGLGlue.cpp

gfx/gl/SkiaGLGlue.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:bd1356ac6b3f
1 /* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "skia/GrContext.h"
7 #include "skia/GrGLInterface.h"
8 #include "mozilla/gfx/2D.h"
9 #include "mozilla/ThreadLocal.h"
10 #include "mozilla/DebugOnly.h"
11
12 /* SkPostConfig.h includes windows.h, which includes windef.h
13 * which redefines min/max. We don't want that. */
14 #ifdef _WIN32
15 #undef min
16 #undef max
17 #endif
18
19 #include "GLContext.h"
20 #include "SkiaGLGlue.h"
21
22 using mozilla::gl::GLContext;
23 using mozilla::gl::GLFeature;
24 using mozilla::gl::SkiaGLGlue;
25 using mozilla::gfx::DrawTarget;
26
27 static mozilla::ThreadLocal<GLContext*> sGLContext;
28
29 extern "C" {
30
31 static void SetStaticGLContext(GLContext* context)
32 {
33 if (!sGLContext.initialized()) {
34 mozilla::DebugOnly<bool> success = sGLContext.init();
35 MOZ_ASSERT(success);
36 }
37
38 sGLContext.set(context);
39 }
40
41 void EnsureGLContext(const GrGLInterface* i)
42 {
43 const SkiaGLGlue* contextSkia = reinterpret_cast<const SkiaGLGlue*>(i->fCallbackData);
44 MOZ_ASSERT(contextSkia);
45 GLContext* gl = contextSkia->GetGLContext();
46 gl->MakeCurrent();
47 SetStaticGLContext(gl);
48 }
49
50 // Core GL functions required by Ganesh
51
52 GrGLvoid glActiveTexture_mozilla(GrGLenum texture)
53 {
54 return sGLContext.get()->fActiveTexture(texture);
55 }
56
57 GrGLvoid glAttachShader_mozilla(GrGLuint program, GrGLuint shader)
58 {
59 return sGLContext.get()->fAttachShader(program, shader);
60 }
61
62 GrGLvoid glBindAttribLocation_mozilla(GrGLuint program, GrGLuint index, const GLchar* name)
63 {
64 return sGLContext.get()->fBindAttribLocation(program, index, name);
65 }
66
67 GrGLvoid glBindBuffer_mozilla(GrGLenum target, GrGLuint buffer)
68 {
69 return sGLContext.get()->fBindBuffer(target, buffer);
70 }
71
72 GrGLvoid glBindFramebuffer_mozilla(GrGLenum target, GrGLuint framebuffer)
73 {
74 return sGLContext.get()->fBindFramebuffer(target, framebuffer);
75 }
76
77 GrGLvoid glBindRenderbuffer_mozilla(GrGLenum target, GrGLuint renderbuffer)
78 {
79 return sGLContext.get()->fBindRenderbuffer(target, renderbuffer);
80 }
81
82 GrGLvoid glBindTexture_mozilla(GrGLenum target, GrGLuint texture)
83 {
84 return sGLContext.get()->fBindTexture(target, texture);
85 }
86
87 GrGLvoid glBlendColor_mozilla(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha)
88 {
89 return sGLContext.get()->fBlendColor(red, green, blue, alpha);
90 }
91
92 GrGLvoid glBlendFunc_mozilla(GrGLenum sfactor, GrGLenum dfactor)
93 {
94 return sGLContext.get()->fBlendFunc(sfactor, dfactor);
95 }
96
97 GrGLvoid glBufferData_mozilla(GrGLenum target, GrGLsizeiptr size, const void* data, GrGLenum usage)
98 {
99 return sGLContext.get()->fBufferData(target, size, data, usage);
100 }
101
102 GrGLvoid glBufferSubData_mozilla(GrGLenum target, GrGLintptr offset, GrGLsizeiptr size, const void* data)
103 {
104 return sGLContext.get()->fBufferSubData(target, offset, size, data);
105 }
106
107 GrGLenum glCheckFramebufferStatus_mozilla(GrGLenum target)
108 {
109 return sGLContext.get()->fCheckFramebufferStatus(target);
110 }
111
112 GrGLvoid glClear_mozilla(GrGLbitfield mask)
113 {
114 return sGLContext.get()->fClear(mask);
115 }
116
117 GrGLvoid glClearColor_mozilla(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha)
118 {
119 return sGLContext.get()->fClearColor(red, green, blue, alpha);
120 }
121
122 GrGLvoid glClearStencil_mozilla(GrGLint s)
123 {
124 return sGLContext.get()->fClearStencil(s);
125 }
126
127 GrGLvoid glColorMask_mozilla(GrGLboolean red, GrGLboolean green, GrGLboolean blue, GrGLboolean alpha)
128 {
129 return sGLContext.get()->fColorMask(red, green, blue, alpha);
130 }
131
132 GrGLvoid glCompileShader_mozilla(GrGLuint shader)
133 {
134 return sGLContext.get()->fCompileShader(shader);
135 }
136
137 GrGLvoid glCopyTexSubImage2D_mozilla(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset,
138 GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
139 {
140 return sGLContext.get()->fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
141 }
142
143 GrGLuint glCreateProgram_mozilla(void)
144 {
145 return sGLContext.get()->fCreateProgram();
146 }
147
148 GrGLuint glCreateShader_mozilla(GrGLenum type)
149 {
150 return sGLContext.get()->fCreateShader(type);
151 }
152
153 GrGLvoid glCullFace_mozilla(GrGLenum mode)
154 {
155 return sGLContext.get()->fCullFace(mode);
156 }
157
158 GrGLvoid glDeleteBuffers_mozilla(GrGLsizei n, const GrGLuint* buffers)
159 {
160 return sGLContext.get()->fDeleteBuffers(n, buffers);
161 }
162
163 GrGLvoid glDeleteFramebuffers_mozilla(GrGLsizei n, const GrGLuint* framebuffers)
164 {
165 return sGLContext.get()->fDeleteFramebuffers(n, framebuffers);
166 }
167
168 GrGLvoid glDeleteProgram_mozilla(GrGLuint program)
169 {
170 return sGLContext.get()->fDeleteProgram(program);
171 }
172
173 GrGLvoid glDeleteRenderbuffers_mozilla(GrGLsizei n, const GrGLuint* renderbuffers)
174 {
175 return sGLContext.get()->fDeleteRenderbuffers(n, renderbuffers);
176 }
177
178 GrGLvoid glDeleteShader_mozilla(GrGLuint shader)
179 {
180 return sGLContext.get()->fDeleteShader(shader);
181 }
182
183 GrGLvoid glDeleteTextures_mozilla(GrGLsizei n, const GrGLuint* textures)
184 {
185 return sGLContext.get()->fDeleteTextures(n, textures);
186 }
187
188 GrGLvoid glDepthMask_mozilla(GrGLboolean flag)
189 {
190 return sGLContext.get()->fDepthMask(flag);
191 }
192
193 GrGLvoid glDisable_mozilla(GrGLenum cap)
194 {
195 return sGLContext.get()->fDisable(cap);
196 }
197
198 GrGLvoid glDisableVertexAttribArray_mozilla(GrGLuint index)
199 {
200 return sGLContext.get()->fDisableVertexAttribArray(index);
201 }
202
203 GrGLvoid glDrawArrays_mozilla(GrGLenum mode, GrGLint first, GrGLsizei count)
204 {
205 return sGLContext.get()->fDrawArrays(mode, first, count);
206 }
207
208 GrGLvoid glDrawElements_mozilla(GrGLenum mode, GrGLsizei count, GrGLenum type, const void* indices)
209 {
210 return sGLContext.get()->fDrawElements(mode, count, type, indices);
211 }
212
213 GrGLvoid glEnable_mozilla(GrGLenum cap)
214 {
215 return sGLContext.get()->fEnable(cap);
216 }
217
218 GrGLvoid glEnableVertexAttribArray_mozilla(GrGLuint index)
219 {
220 return sGLContext.get()->fEnableVertexAttribArray(index);
221 }
222
223 GrGLvoid glFinish_mozilla()
224 {
225 return sGLContext.get()->fFinish();
226 }
227
228 GrGLvoid glFlush_mozilla()
229 {
230 return sGLContext.get()->fFlush();
231 }
232
233 GrGLvoid glFramebufferRenderbuffer_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer)
234 {
235 return sGLContext.get()->fFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
236 }
237
238 GrGLvoid glFramebufferTexture2D_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level)
239 {
240 return sGLContext.get()->fFramebufferTexture2D(target, attachment, textarget, texture, level);
241 }
242
243 GrGLvoid glFrontFace_mozilla(GrGLenum mode)
244 {
245 return sGLContext.get()->fFrontFace(mode);
246 }
247
248 GrGLvoid glGenBuffers_mozilla(GrGLsizei n, GrGLuint* buffers)
249 {
250 return sGLContext.get()->fGenBuffers(n, buffers);
251 }
252
253 GrGLvoid glGenFramebuffers_mozilla(GrGLsizei n, GrGLuint* framebuffers)
254 {
255 return sGLContext.get()->fGenFramebuffers(n, framebuffers);
256 }
257
258 GrGLvoid glGenRenderbuffers_mozilla(GrGLsizei n, GrGLuint* renderbuffers)
259 {
260 return sGLContext.get()->fGenRenderbuffers(n, renderbuffers);
261 }
262
263 GrGLvoid glGenTextures_mozilla(GrGLsizei n, GrGLuint* textures)
264 {
265 return sGLContext.get()->fGenTextures(n, textures);
266 }
267
268 GrGLvoid glGenerateMipmap_mozilla(GrGLenum target)
269 {
270 return sGLContext.get()->fGenerateMipmap(target);
271 }
272
273 GrGLvoid glGetBufferParameteriv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
274 {
275 return sGLContext.get()->fGetBufferParameteriv(target, pname, params);
276 }
277
278 GrGLvoid glGetFramebufferAttachmentParameteriv_mozilla(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params)
279 {
280 return sGLContext.get()->fGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
281 }
282
283 GrGLenum glGetError_mozilla()
284 {
285 return sGLContext.get()->fGetError();
286 }
287
288 GrGLvoid glGetIntegerv_mozilla(GrGLenum pname, GrGLint* params)
289 {
290 return sGLContext.get()->fGetIntegerv(pname, params);
291 }
292
293 GrGLvoid glGetProgramInfoLog_mozilla(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, char* infolog)
294 {
295 return sGLContext.get()->fGetProgramInfoLog(program, bufsize, length, infolog);
296 }
297
298 GrGLvoid glGetProgramiv_mozilla(GrGLuint program, GrGLenum pname, GrGLint* params)
299 {
300 return sGLContext.get()->fGetProgramiv(program, pname, params);
301 }
302
303 GrGLvoid glGetRenderbufferParameteriv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
304 {
305 return sGLContext.get()->fGetRenderbufferParameteriv(target, pname, params);
306 }
307
308 GrGLvoid glGetShaderInfoLog_mozilla(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length, char* infolog)
309 {
310 return sGLContext.get()->fGetShaderInfoLog(shader, bufsize, length, infolog);
311 }
312
313 GrGLvoid glGetShaderiv_mozilla(GrGLuint shader, GrGLenum pname, GrGLint* params)
314 {
315 return sGLContext.get()->fGetShaderiv(shader, pname, params);
316 }
317
318 const GLubyte* glGetString_mozilla(GrGLenum name)
319 {
320 // GLContext only exposes a OpenGL 2.0 style API, so we have to intercept a bunch
321 // of checks that Ganesh makes to determine which capabilities are present
322 // on the GL implementation and change them to match what GLContext actually exposes.
323
324 if (name == LOCAL_GL_VERSION) {
325 if (sGLContext.get()->IsGLES()) {
326 return reinterpret_cast<const GLubyte*>("OpenGL ES 2.0");
327 } else {
328 return reinterpret_cast<const GLubyte*>("2.0");
329 }
330 } else if (name == LOCAL_GL_EXTENSIONS) {
331 // Only expose the bare minimum extensions we want to support to ensure a functional Ganesh
332 // as GLContext only exposes certain extensions
333 static bool extensionsStringBuilt = false;
334 static char extensionsString[1024];
335
336 if (!extensionsStringBuilt) {
337 extensionsString[0] = '\0';
338
339 if (sGLContext.get()->IsGLES()) {
340 // OES is only applicable to GLES2
341 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_packed_depth_stencil)) {
342 strcat(extensionsString, "GL_OES_packed_depth_stencil ");
343 }
344
345 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_rgb8_rgba8)) {
346 strcat(extensionsString, "GL_OES_rgb8_rgba8 ");
347 }
348
349 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_texture_npot)) {
350 strcat(extensionsString, "GL_OES_texture_npot ");
351 }
352
353 if (sGLContext.get()->IsExtensionSupported(GLContext::OES_vertex_array_object)) {
354 strcat(extensionsString, "GL_OES_vertex_array_object ");
355 }
356
357 if (sGLContext.get()->IsSupported(GLFeature::standard_derivatives)) {
358 strcat(extensionsString, "GL_OES_standard_derivatives ");
359 }
360 }
361
362 if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_texture_format_BGRA8888)) {
363 strcat(extensionsString, "GL_EXT_texture_format_BGRA8888 ");
364 }
365
366 if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_packed_depth_stencil)) {
367 strcat(extensionsString, "GL_EXT_packed_depth_stencil ");
368 }
369
370 if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_bgra)) {
371 strcat(extensionsString, "GL_EXT_bgra ");
372 }
373
374 if (sGLContext.get()->IsExtensionSupported(GLContext::EXT_read_format_bgra)) {
375 strcat(extensionsString, "GL_EXT_read_format_bgra ");
376 }
377
378 extensionsStringBuilt = true;
379 #ifdef DEBUG
380 printf_stderr("Exported SkiaGL extensions: %s\n", extensionsString);
381 #endif
382 }
383
384 return reinterpret_cast<const GLubyte*>(extensionsString);
385
386 } else if (name == LOCAL_GL_SHADING_LANGUAGE_VERSION) {
387 if (sGLContext.get()->IsGLES()) {
388 return reinterpret_cast<const GLubyte*>("OpenGL ES GLSL ES 1.0");
389 } else {
390 return reinterpret_cast<const GLubyte*>("1.10");
391 }
392 }
393
394 return sGLContext.get()->fGetString(name);
395 }
396
397 GrGLint glGetUniformLocation_mozilla(GrGLuint program, const char* name)
398 {
399 return sGLContext.get()->fGetUniformLocation(program, name);
400 }
401
402 GrGLvoid glLineWidth_mozilla(GrGLfloat width)
403 {
404 return sGLContext.get()->fLineWidth(width);
405 }
406
407 GrGLvoid glLinkProgram_mozilla(GrGLuint program)
408 {
409 return sGLContext.get()->fLinkProgram(program);
410 }
411
412 GrGLvoid glPixelStorei_mozilla(GrGLenum pname, GrGLint param)
413 {
414 return sGLContext.get()->fPixelStorei(pname, param);
415 }
416
417 GrGLvoid glReadPixels_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height,
418 GrGLenum format, GrGLenum type, void* pixels)
419 {
420 return sGLContext.get()->fReadPixels(x, y, width, height,
421 format, type, pixels);
422 }
423
424 GrGLvoid glRenderbufferStorage_mozilla(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height)
425 {
426 return sGLContext.get()->fRenderbufferStorage(target, internalformat, width, height);
427 }
428
429 GrGLvoid glScissor_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
430 {
431 return sGLContext.get()->fScissor(x, y, width, height);
432 }
433
434 GrGLvoid glShaderSource_mozilla(GrGLuint shader, GrGLsizei count, const char** str, const GrGLint* length)
435 {
436 return sGLContext.get()->fShaderSource(shader, count, str, length);
437 }
438
439 GrGLvoid glStencilFunc_mozilla(GrGLenum func, GrGLint ref, GrGLuint mask)
440 {
441 return sGLContext.get()->fStencilFunc(func, ref, mask);
442 }
443
444 GrGLvoid glStencilMask_mozilla(GrGLuint mask)
445 {
446 return sGLContext.get()->fStencilMask(mask);
447 }
448
449 GrGLvoid glStencilOp_mozilla(GrGLenum fail, GrGLenum zfail, GrGLenum zpass)
450 {
451 return sGLContext.get()->fStencilOp(fail, zfail, zpass);
452 }
453
454 GrGLvoid glTexImage2D_mozilla(GrGLenum target, GrGLint level, GrGLint internalformat,
455 GrGLsizei width, GrGLsizei height, GrGLint border,
456 GrGLenum format, GrGLenum type, const void* pixels)
457 {
458 return sGLContext.get()->fTexImage2D(target, level, internalformat,
459 width, height, border,
460 format, type, pixels);
461 }
462
463 GrGLvoid glTexParameteri_mozilla(GrGLenum target, GrGLenum pname, GrGLint param)
464 {
465 return sGLContext.get()->fTexParameteri(target, pname, param);
466 }
467
468 GrGLvoid glTexParameteriv_mozilla(GrGLenum target, GrGLenum pname, const GrGLint* params)
469 {
470 return sGLContext.get()->fTexParameteriv(target, pname, params);
471 }
472
473 GrGLvoid glTexSubImage2D_mozilla(GrGLenum target, GrGLint level,
474 GrGLint xoffset, GrGLint yoffset,
475 GrGLsizei width, GrGLsizei height,
476 GrGLenum format, GrGLenum type, const void* pixels)
477 {
478 return sGLContext.get()->fTexSubImage2D(target, level,
479 xoffset, yoffset,
480 width, height,
481 format, type, pixels);
482 }
483
484 GrGLvoid glUniform1f_mozilla(GrGLint location, GrGLfloat v)
485 {
486 return sGLContext.get()->fUniform1f(location, v);
487 }
488
489 GrGLvoid glUniform1i_mozilla(GrGLint location, GrGLint v)
490 {
491 return sGLContext.get()->fUniform1i(location, v);
492 }
493
494 GrGLvoid glUniform1fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
495 {
496 return sGLContext.get()->fUniform1fv(location, count, v);
497 }
498
499 GrGLvoid glUniform1iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
500 {
501 return sGLContext.get()->fUniform1iv(location, count, v);
502 }
503
504 GrGLvoid glUniform2f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1)
505 {
506 return sGLContext.get()->fUniform2f(location, v0, v1);
507 }
508
509 GrGLvoid glUniform2i_mozilla(GrGLint location, GrGLint v0, GrGLint v1)
510 {
511 return sGLContext.get()->fUniform2i(location, v0, v1);
512 }
513
514 GrGLvoid glUniform2fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
515 {
516 return sGLContext.get()->fUniform2fv(location, count, v);
517 }
518
519 GrGLvoid glUniform2iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
520 {
521 return sGLContext.get()->fUniform2iv(location, count, v);
522 }
523
524 GrGLvoid glUniform3f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2)
525 {
526 return sGLContext.get()->fUniform3f(location, v0, v1, v2);
527 }
528
529 GrGLvoid glUniform3i_mozilla(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2)
530 {
531 return sGLContext.get()->fUniform3i(location, v0, v1, v2);
532 }
533
534 GrGLvoid glUniform3fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
535 {
536 return sGLContext.get()->fUniform3fv(location, count, v);
537 }
538
539 GrGLvoid glUniform3iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
540 {
541 return sGLContext.get()->fUniform3iv(location, count, v);
542 }
543
544 GrGLvoid glUniform4f_mozilla(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2, GrGLfloat v3)
545 {
546 return sGLContext.get()->fUniform4f(location, v0, v1, v2, v3);
547 }
548
549 GrGLvoid glUniform4i_mozilla(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3)
550 {
551 return sGLContext.get()->fUniform4i(location, v0, v1, v2, v3);
552 }
553
554 GrGLvoid glUniform4fv_mozilla(GrGLint location, GrGLsizei count, const GrGLfloat* v)
555 {
556 return sGLContext.get()->fUniform4fv(location, count, v);
557 }
558
559 GrGLvoid glUniform4iv_mozilla(GrGLint location, GrGLsizei count, const GrGLint* v)
560 {
561 return sGLContext.get()->fUniform4iv(location, count, v);
562 }
563
564 GrGLvoid glUniformMatrix2fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
565 {
566 return sGLContext.get()->fUniformMatrix2fv(location, count, transpose, value);
567 }
568
569 GrGLvoid glUniformMatrix3fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
570 {
571 return sGLContext.get()->fUniformMatrix3fv(location, count, transpose, value);
572 }
573
574 GrGLvoid glUniformMatrix4fv_mozilla(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value)
575 {
576 return sGLContext.get()->fUniformMatrix4fv(location, count, transpose, value);
577 }
578
579 GrGLvoid glUseProgram_mozilla(GrGLuint program)
580 {
581 return sGLContext.get()->fUseProgram(program);
582 }
583
584 GrGLvoid glVertexAttrib4fv_mozilla(GrGLuint index, const GrGLfloat* values)
585 {
586 return sGLContext.get()->fVertexAttrib4fv(index, values);
587 }
588
589 GrGLvoid glVertexAttribPointer_mozilla(GrGLuint index, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, const void* ptr)
590 {
591 return sGLContext.get()->fVertexAttribPointer(index, size, type, normalized, stride, ptr);
592 }
593
594 GrGLvoid glViewport_mozilla(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height)
595 {
596 return sGLContext.get()->fViewport(x, y, width, height);
597 }
598
599 // Required if the bindings are GLES2 or desktop OpenGL 2.0
600
601 GrGLvoid glStencilFuncSeparate_mozilla(GrGLenum frontfunc, GrGLenum backfunc, GrGLint ref, GrGLuint mask)
602 {
603 return sGLContext.get()->fStencilFuncSeparate(frontfunc, backfunc, ref, mask);
604 }
605
606 GrGLvoid glStencilMaskSeparate_mozilla(GrGLenum face, GrGLuint mask)
607 {
608 return sGLContext.get()->fStencilMaskSeparate(face, mask);
609 }
610
611 GrGLvoid glStencilOpSeparate_mozilla(GrGLenum face, GrGLenum sfail, GrGLenum dpfail, GrGLenum dppass)
612 {
613 return sGLContext.get()->fStencilOpSeparate(face, sfail, dpfail, dppass);
614 }
615
616 // Not in GLES2
617
618 GrGLvoid glGetTexLevelParameteriv_mozilla(GrGLenum target, GrGLint level, GrGLenum pname, GrGLint *params)
619 {
620 return sGLContext.get()->fGetTexLevelParameteriv(target, level, pname, params);
621 }
622
623 GrGLvoid glDrawBuffer_mozilla(GrGLenum mode)
624 {
625 return sGLContext.get()->fDrawBuffer(mode);
626 }
627
628 GrGLvoid glReadBuffer_mozilla(GrGLenum mode)
629 {
630 return sGLContext.get()->fReadBuffer(mode);
631 }
632
633 // Desktop OpenGL version >= 1.5
634
635 GrGLvoid glGenQueries_mozilla(GrGLsizei n, GrGLuint* ids)
636 {
637 return sGLContext.get()->fGenQueries(n, ids);
638 }
639
640 GrGLvoid glDeleteQueries_mozilla(GrGLsizei n, const GrGLuint* ids)
641 {
642 return sGLContext.get()->fDeleteQueries(n, ids);
643 }
644
645 GrGLvoid glBeginQuery_mozilla(GrGLenum target, GrGLuint id)
646 {
647 return sGLContext.get()->fBeginQuery(target, id);
648 }
649
650 GrGLvoid glEndQuery_mozilla(GrGLenum target)
651 {
652 return sGLContext.get()->fEndQuery(target);
653 }
654
655 GrGLvoid glGetQueryiv_mozilla(GrGLenum target, GrGLenum pname, GrGLint* params)
656 {
657 return sGLContext.get()->fGetQueryiv(target, pname, params);
658 }
659
660 GrGLvoid glGetQueryObjectiv_mozilla(GrGLuint id, GrGLenum pname, GrGLint* params)
661 {
662 return sGLContext.get()->fGetQueryObjectiv(id, pname, params);
663 }
664
665 GrGLvoid glGetQueryObjectuiv_mozilla(GrGLuint id, GrGLenum pname, GrGLuint* params)
666 {
667 return sGLContext.get()->fGetQueryObjectuiv(id, pname, params);
668 }
669
670 // Desktop OpenGL version >= 2.0
671
672 GrGLvoid glDrawBuffers_mozilla(GrGLsizei n, const GrGLenum* bufs)
673 {
674 return sGLContext.get()->fDrawBuffers(n, bufs);
675 }
676
677 // GLContext supports glMapBuffer on everything (GL_OES_mapbuffer)
678
679 GrGLvoid* glMapBuffer_mozilla(GrGLenum target, GrGLenum access)
680 {
681 return sGLContext.get()->fMapBuffer(target, access);
682 }
683
684 GrGLboolean glUnmapBuffer_mozilla(GrGLenum target)
685 {
686 return sGLContext.get()->fUnmapBuffer(target);
687 }
688
689 // GLContext supports glCompressedTexImage2D (GL_ARB_texture_compression)
690
691 GrGLvoid glCompressedTexImage2D_mozilla(GrGLenum target, GrGLint level, GrGLenum internalformat,
692 GrGLsizei width, GrGLsizei height, GrGLint border,
693 GrGLsizei imageSize, const GrGLvoid* pixels)
694 {
695 return sGLContext.get()->fCompressedTexImage2D(target, level, internalformat,
696 width, height, border,
697 imageSize, pixels);
698 }
699
700 // GLContext supports glBlitFramebuffer/glRenderbufferStorageMultisample (GL_ARB_framebuffer_object)
701
702 GrGLvoid glRenderbufferStorageMultisample_mozilla(GrGLenum target, GrGLsizei samples, GrGLenum internalformat,
703 GrGLsizei width, GrGLsizei height)
704 {
705 return sGLContext.get()->fRenderbufferStorageMultisample(target, samples, internalformat,
706 width, height);
707 }
708
709 GrGLvoid glBlitFramebuffer_mozilla(GrGLint srcX0, GrGLint srcY0,
710 GrGLint srcX1, GrGLint srcY1,
711 GrGLint dstX0, GrGLint dstY0,
712 GrGLint dstX1, GrGLint dstY1,
713 GrGLbitfield mask, GrGLenum filter) {
714 return sGLContext.get()->fBlitFramebuffer(srcX0, srcY0,
715 srcX1, srcY1,
716 dstX0, dstY0,
717 dstX1, dstY1,
718 mask, filter);
719 }
720
721 GrGLvoid glBindVertexArray_mozilla(GrGLuint array) {
722 return sGLContext.get()->fBindVertexArray(array);
723 }
724
725 GrGLvoid glDeleteVertexArrays_mozilla(GrGLsizei n, const GrGLuint *arrays) {
726 return sGLContext.get()->fDeleteVertexArrays(n, arrays);
727 }
728
729 GrGLvoid glGenVertexArrays_mozilla(GrGLsizei n, GrGLuint *arrays) {
730 return sGLContext.get()->fGenVertexArrays(n, arrays);
731 }
732
733 // Additional functions required for desktop GL < version 3.2
734
735 GrGLvoid glLoadMatrixf_mozilla(const GLfloat* matrix)
736 {
737 return sGLContext.get()->fLoadMatrixf(matrix);
738 }
739
740 GrGLvoid glLoadIdentity_mozilla()
741 {
742 return sGLContext.get()->fLoadIdentity();
743 }
744
745 GrGLvoid glMatrixMode_mozilla(GrGLenum mode)
746 {
747 return sGLContext.get()->fMatrixMode(mode);
748 }
749
750 GrGLvoid glTexGeni_mozilla(GrGLenum coord, GrGLenum pname, GrGLint param)
751 {
752 return sGLContext.get()->fTexGeni(coord, pname, param);
753 }
754
755 GrGLvoid glTexGenfv_mozilla(GrGLenum coord, GrGLenum pname, const GrGLfloat* param)
756 {
757 return sGLContext.get()->fTexGenfv(coord, pname, param);
758 }
759
760 } // extern "C"
761
762 static GrGLInterface* CreateGrGLInterfaceFromGLContext(GLContext* context)
763 {
764 SetStaticGLContext(context);
765
766 GrGLInterface* i = new GrGLInterface();
767 i->fCallback = EnsureGLContext;
768 i->fCallbackData = 0; // must be later initialized to be a valid DrawTargetSkia* pointer
769
770 context->MakeCurrent();
771
772 // We support both desktop GL and GLES2
773 if (context->IsGLES()) {
774 i->fStandard = kGLES_GrGLStandard;
775 } else {
776 i->fStandard = kGL_GrGLStandard;
777 }
778
779 GrGLExtensions extensions;
780 if (!extensions.init(i->fStandard, glGetString_mozilla, NULL, glGetIntegerv_mozilla)) {
781 return nullptr;
782 }
783
784 i->fExtensions.swap(&extensions);
785
786 // Core GL functions required by Ganesh
787 i->fFunctions.fActiveTexture = glActiveTexture_mozilla;
788 i->fFunctions.fAttachShader = glAttachShader_mozilla;
789 i->fFunctions.fBindAttribLocation = glBindAttribLocation_mozilla;
790 i->fFunctions.fBindBuffer = glBindBuffer_mozilla;
791 i->fFunctions.fBindFramebuffer = glBindFramebuffer_mozilla;
792 i->fFunctions.fBindRenderbuffer = glBindRenderbuffer_mozilla;
793 i->fFunctions.fBindTexture = glBindTexture_mozilla;
794 i->fFunctions.fBlendFunc = glBlendFunc_mozilla;
795 i->fFunctions.fBlendColor = glBlendColor_mozilla;
796 i->fFunctions.fBufferData = glBufferData_mozilla;
797 i->fFunctions.fBufferSubData = glBufferSubData_mozilla;
798 i->fFunctions.fCheckFramebufferStatus = glCheckFramebufferStatus_mozilla;
799 i->fFunctions.fClear = glClear_mozilla;
800 i->fFunctions.fClearColor = glClearColor_mozilla;
801 i->fFunctions.fClearStencil = glClearStencil_mozilla;
802 i->fFunctions.fColorMask = glColorMask_mozilla;
803 i->fFunctions.fCompileShader = glCompileShader_mozilla;
804 i->fFunctions.fCopyTexSubImage2D = glCopyTexSubImage2D_mozilla;
805 i->fFunctions.fCreateProgram = glCreateProgram_mozilla;
806 i->fFunctions.fCreateShader = glCreateShader_mozilla;
807 i->fFunctions.fCullFace = glCullFace_mozilla;
808 i->fFunctions.fDeleteBuffers = glDeleteBuffers_mozilla;
809 i->fFunctions.fDeleteFramebuffers = glDeleteFramebuffers_mozilla;
810 i->fFunctions.fDeleteProgram = glDeleteProgram_mozilla;
811 i->fFunctions.fDeleteRenderbuffers = glDeleteRenderbuffers_mozilla;
812 i->fFunctions.fDeleteShader = glDeleteShader_mozilla;
813 i->fFunctions.fDeleteTextures = glDeleteTextures_mozilla;
814 i->fFunctions.fDepthMask = glDepthMask_mozilla;
815 i->fFunctions.fDisable = glDisable_mozilla;
816 i->fFunctions.fDisableVertexAttribArray = glDisableVertexAttribArray_mozilla;
817 i->fFunctions.fDrawArrays = glDrawArrays_mozilla;
818 i->fFunctions.fDrawElements = glDrawElements_mozilla;
819 i->fFunctions.fEnable = glEnable_mozilla;
820 i->fFunctions.fEnableVertexAttribArray = glEnableVertexAttribArray_mozilla;
821 i->fFunctions.fFinish = glFinish_mozilla;
822 i->fFunctions.fFlush = glFlush_mozilla;
823 i->fFunctions.fFramebufferRenderbuffer = glFramebufferRenderbuffer_mozilla;
824 i->fFunctions.fFramebufferTexture2D = glFramebufferTexture2D_mozilla;
825 i->fFunctions.fFrontFace = glFrontFace_mozilla;
826 i->fFunctions.fGenBuffers = glGenBuffers_mozilla;
827 i->fFunctions.fGenFramebuffers = glGenFramebuffers_mozilla;
828 i->fFunctions.fGenRenderbuffers = glGenRenderbuffers_mozilla;
829 i->fFunctions.fGetFramebufferAttachmentParameteriv = glGetFramebufferAttachmentParameteriv_mozilla;
830 i->fFunctions.fGenTextures = glGenTextures_mozilla;
831 i->fFunctions.fGenerateMipmap = glGenerateMipmap_mozilla;
832 i->fFunctions.fGetBufferParameteriv = glGetBufferParameteriv_mozilla;
833 i->fFunctions.fGetError = glGetError_mozilla;
834 i->fFunctions.fGetIntegerv = glGetIntegerv_mozilla;
835 i->fFunctions.fGetProgramInfoLog = glGetProgramInfoLog_mozilla;
836 i->fFunctions.fGetProgramiv = glGetProgramiv_mozilla;
837 i->fFunctions.fGetRenderbufferParameteriv = glGetRenderbufferParameteriv_mozilla;
838 i->fFunctions.fGetShaderInfoLog = glGetShaderInfoLog_mozilla;
839 i->fFunctions.fGetShaderiv = glGetShaderiv_mozilla;
840 i->fFunctions.fGetString = glGetString_mozilla;
841 i->fFunctions.fGetUniformLocation = glGetUniformLocation_mozilla;
842 i->fFunctions.fLineWidth = glLineWidth_mozilla;
843 i->fFunctions.fLinkProgram = glLinkProgram_mozilla;
844 i->fFunctions.fPixelStorei = glPixelStorei_mozilla;
845 i->fFunctions.fReadPixels = glReadPixels_mozilla;
846 i->fFunctions.fRenderbufferStorage = glRenderbufferStorage_mozilla;
847 i->fFunctions.fScissor = glScissor_mozilla;
848 i->fFunctions.fShaderSource = glShaderSource_mozilla;
849 i->fFunctions.fStencilFunc = glStencilFunc_mozilla;
850 i->fFunctions.fStencilMask = glStencilMask_mozilla;
851 i->fFunctions.fStencilOp = glStencilOp_mozilla;
852 i->fFunctions.fTexImage2D = glTexImage2D_mozilla;
853 i->fFunctions.fTexParameteri = glTexParameteri_mozilla;
854 i->fFunctions.fTexParameteriv = glTexParameteriv_mozilla;
855 i->fFunctions.fTexSubImage2D = glTexSubImage2D_mozilla;
856 i->fFunctions.fUniform1f = glUniform1f_mozilla;
857 i->fFunctions.fUniform1i = glUniform1i_mozilla;
858 i->fFunctions.fUniform1fv = glUniform1fv_mozilla;
859 i->fFunctions.fUniform1iv = glUniform1iv_mozilla;
860 i->fFunctions.fUniform2f = glUniform2f_mozilla;
861 i->fFunctions.fUniform2i = glUniform2i_mozilla;
862 i->fFunctions.fUniform2fv = glUniform2fv_mozilla;
863 i->fFunctions.fUniform2iv = glUniform2iv_mozilla;
864 i->fFunctions.fUniform3f = glUniform3f_mozilla;
865 i->fFunctions.fUniform3i = glUniform3i_mozilla;
866 i->fFunctions.fUniform3fv = glUniform3fv_mozilla;
867 i->fFunctions.fUniform3iv = glUniform3iv_mozilla;
868 i->fFunctions.fUniform4f = glUniform4f_mozilla;
869 i->fFunctions.fUniform4i = glUniform4i_mozilla;
870 i->fFunctions.fUniform4fv = glUniform4fv_mozilla;
871 i->fFunctions.fUniform4iv = glUniform4iv_mozilla;
872 i->fFunctions.fUniformMatrix2fv = glUniformMatrix2fv_mozilla;
873 i->fFunctions.fUniformMatrix3fv = glUniformMatrix3fv_mozilla;
874 i->fFunctions.fUniformMatrix4fv = glUniformMatrix4fv_mozilla;
875 i->fFunctions.fUseProgram = glUseProgram_mozilla;
876 i->fFunctions.fVertexAttrib4fv = glVertexAttrib4fv_mozilla;
877 i->fFunctions.fVertexAttribPointer = glVertexAttribPointer_mozilla;
878 i->fFunctions.fViewport = glViewport_mozilla;
879
880 // Required for either desktop OpenGL 2.0 or OpenGL ES 2.0
881 i->fFunctions.fStencilFuncSeparate = glStencilFuncSeparate_mozilla;
882 i->fFunctions.fStencilMaskSeparate = glStencilMaskSeparate_mozilla;
883 i->fFunctions.fStencilOpSeparate = glStencilOpSeparate_mozilla;
884
885 // GLContext supports glMapBuffer
886 i->fFunctions.fMapBuffer = glMapBuffer_mozilla;
887 i->fFunctions.fUnmapBuffer = glUnmapBuffer_mozilla;
888
889 // GLContext supports glRenderbufferStorageMultisample/glBlitFramebuffer
890 i->fFunctions.fRenderbufferStorageMultisample = glRenderbufferStorageMultisample_mozilla;
891 i->fFunctions.fBlitFramebuffer = glBlitFramebuffer_mozilla;
892
893 // GLContext supports glCompressedTexImage2D
894 i->fFunctions.fCompressedTexImage2D = glCompressedTexImage2D_mozilla;
895
896 // GL_OES_vertex_array_object
897 i->fFunctions.fBindVertexArray = glBindVertexArray_mozilla;
898 i->fFunctions.fDeleteVertexArrays = glDeleteVertexArrays_mozilla;
899 i->fFunctions.fGenVertexArrays = glGenVertexArrays_mozilla;
900
901 // Desktop GL
902 i->fFunctions.fGetTexLevelParameteriv = glGetTexLevelParameteriv_mozilla;
903 i->fFunctions.fDrawBuffer = glDrawBuffer_mozilla;
904 i->fFunctions.fReadBuffer = glReadBuffer_mozilla;
905
906 // Desktop OpenGL > 1.5
907 i->fFunctions.fGenQueries = glGenQueries_mozilla;
908 i->fFunctions.fDeleteQueries = glDeleteQueries_mozilla;
909 i->fFunctions.fBeginQuery = glBeginQuery_mozilla;
910 i->fFunctions.fEndQuery = glEndQuery_mozilla;
911 i->fFunctions.fGetQueryiv = glGetQueryiv_mozilla;
912 i->fFunctions.fGetQueryObjectiv = glGetQueryObjectiv_mozilla;
913 i->fFunctions.fGetQueryObjectuiv = glGetQueryObjectuiv_mozilla;
914
915 // Desktop OpenGL > 2.0
916 i->fFunctions.fDrawBuffers = glDrawBuffers_mozilla;
917
918 // Desktop OpenGL < 3.2 (which we pretend to be)
919 i->fFunctions.fLoadIdentity = glLoadIdentity_mozilla;
920 i->fFunctions.fLoadMatrixf = glLoadMatrixf_mozilla;
921 i->fFunctions.fMatrixMode = glMatrixMode_mozilla;
922 i->fFunctions.fTexGenfv = glTexGenfv_mozilla;
923 i->fFunctions.fTexGeni = glTexGeni_mozilla;
924
925 return i;
926 }
927
928 SkiaGLGlue::SkiaGLGlue(GLContext* context)
929 : mGLContext(context)
930 {
931 SkAutoTUnref<GrGLInterface> i(CreateGrGLInterfaceFromGLContext(mGLContext));
932 i->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(this);
933 mGrGLInterface = i;
934 SkAutoTUnref<GrContext> gr(GrContext::Create(kOpenGL_GrBackend, (GrBackendContext)mGrGLInterface.get()));
935
936 mGrContext = gr;
937 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial