| /* |
| * Copyright (C) 2010 Apple Inc. All rights reserved. |
| * Copyright (C) 2010 Google Inc. All rights reserved. |
| * Copyright (C) 2011 Igalia S.L. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "GraphicsContextGLOpenGL.h" |
| |
| #if ENABLE(GRAPHICS_CONTEXT_GL) && USE(TEXTURE_MAPPER) |
| |
| #include "GraphicsContextGLOpenGLPrivate.h" |
| #include "TextureMapperGC3DPlatformLayer.h" |
| #include <ANGLE/ShaderLang.h> |
| #include <wtf/Deque.h> |
| #include <wtf/NeverDestroyed.h> |
| |
| #if USE(ANGLE) |
| #define EGL_EGL_PROTOTYPES 0 |
| // Skip the inclusion of ANGLE's explicit context entry points for now. |
| #define GL_ANGLE_explicit_context |
| #define GL_ANGLE_explicit_context_gles1 |
| typedef void* GLeglContext; |
| #include <ANGLE/egl.h> |
| #include <ANGLE/eglext.h> |
| #include <ANGLE/eglext_angle.h> |
| #include <ANGLE/entry_points_egl.h> |
| #include <ANGLE/entry_points_gles_2_0_autogen.h> |
| #include <ANGLE/entry_points_gles_ext_autogen.h> |
| #include <ANGLE/gl2ext.h> |
| #include <ANGLE/gl2ext_angle.h> |
| #if defined(Above) |
| #undef Above |
| #endif |
| #if defined(Below) |
| #undef Below |
| #endif |
| #if defined(None) |
| #undef None |
| #endif |
| #elif USE(LIBEPOXY) |
| #include <epoxy/gl.h> |
| #elif !USE(OPENGL_ES) |
| #include "OpenGLShims.h" |
| #endif |
| |
| #if USE(ANGLE) |
| #include "ExtensionsGLANGLE.h" |
| #elif USE(OPENGL_ES) |
| #include "ExtensionsGLOpenGLES.h" |
| #else |
| #include "ExtensionsGLOpenGL.h" |
| #endif |
| |
| #if USE(NICOSIA) |
| #if USE(ANGLE) |
| #include "NicosiaGC3DANGLELayer.h" |
| #else |
| #include "NicosiaGC3DLayer.h" |
| #endif |
| #endif |
| |
| namespace WebCore { |
| |
| static const size_t MaxActiveContexts = 16; |
| static Deque<GraphicsContextGLOpenGL*, MaxActiveContexts>& activeContexts() |
| { |
| static NeverDestroyed<Deque<GraphicsContextGLOpenGL*, MaxActiveContexts>> s_activeContexts; |
| return s_activeContexts; |
| } |
| |
| RefPtr<GraphicsContextGLOpenGL> GraphicsContextGLOpenGL::create(GraphicsContextGLAttributes attributes, HostWindow* hostWindow, GraphicsContextGLOpenGL::Destination destination) |
| { |
| // This implementation doesn't currently support rendering directly to the HostWindow. |
| if (destination == Destination::DirectlyToHostWindow) |
| return nullptr; |
| |
| static bool initialized = false; |
| static bool success = true; |
| if (!initialized) { |
| #if !USE(OPENGL_ES) && !USE(LIBEPOXY) && !USE(ANGLE) |
| success = initializeOpenGLShims(); |
| #endif |
| initialized = true; |
| } |
| if (!success) |
| return nullptr; |
| |
| auto& contexts = activeContexts(); |
| if (contexts.size() >= MaxActiveContexts) |
| contexts.first()->recycleContext(); |
| |
| // Calling recycleContext() above should have lead to the graphics context being |
| // destroyed and thus removed from the active contexts list. |
| if (contexts.size() >= MaxActiveContexts) |
| return nullptr; |
| |
| // Create the GraphicsContextGLOpenGL object first in order to establist a current context on this thread. |
| auto context = adoptRef(new GraphicsContextGLOpenGL(attributes, hostWindow, destination)); |
| |
| #if USE(LIBEPOXY) && USE(OPENGL_ES) |
| // Bail if GLES3 was requested but cannot be provided. |
| if (attributes.isWebGL2 && !epoxy_is_desktop_gl() && epoxy_gl_version() < 30) |
| return nullptr; |
| #endif |
| |
| contexts.append(context.get()); |
| return context; |
| } |
| |
| #if USE(ANGLE) |
| GraphicsContextGLOpenGL::GraphicsContextGLOpenGL(GraphicsContextGLAttributes attributes, HostWindow*, GraphicsContextGLOpenGL::Destination destination, GraphicsContextGLOpenGL* sharedContext) |
| : GraphicsContextGL(attributes, destination, sharedContext) |
| { |
| ASSERT_UNUSED(sharedContext, !sharedContext); |
| #if USE(NICOSIA) |
| m_nicosiaLayer = WTF::makeUnique<Nicosia::GC3DANGLELayer>(*this, destination); |
| #else |
| m_texmapLayer = WTF::makeUnique<TextureMapperGC3DPlatformLayer>(*this, destination); |
| #endif |
| makeContextCurrent(); |
| |
| validateAttributes(); |
| attributes = contextAttributes(); // They may have changed during validation. |
| |
| if (destination == Destination::Offscreen) { |
| // Create a texture to render into. |
| gl::GenTextures(1, &m_texture); |
| gl::BindTexture(GL_TEXTURE_RECTANGLE_ANGLE, m_texture); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| gl::BindTexture(GL_TEXTURE_RECTANGLE_ANGLE, 0); |
| |
| // Create an FBO. |
| gl::GenFramebuffers(1, &m_fbo); |
| gl::BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| |
| #if USE(COORDINATED_GRAPHICS) |
| gl::GenTextures(1, &m_compositorTexture); |
| gl::BindTexture(GL_TEXTURE_RECTANGLE_ANGLE, m_compositorTexture); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| gl::GenTextures(1, &m_intermediateTexture); |
| gl::BindTexture(GL_TEXTURE_RECTANGLE_ANGLE, m_intermediateTexture); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| gl::TexParameterf(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl::TexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| gl::BindTexture(GL_TEXTURE_RECTANGLE_ANGLE, 0); |
| #endif |
| |
| // Create a multisample FBO. |
| ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO); |
| if (attributes.antialias) { |
| gl::GenFramebuffers(1, &m_multisampleFBO); |
| gl::BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); |
| m_state.boundDrawFBO = m_state.boundReadFBO = m_multisampleFBO; |
| gl::GenRenderbuffers(1, &m_multisampleColorBuffer); |
| if (attributes.stencil || attributes.depth) |
| gl::GenRenderbuffers(1, &m_multisampleDepthStencilBuffer); |
| } else { |
| // Bind canvas FBO. |
| gl::BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| m_state.boundDrawFBO = m_state.boundReadFBO = m_fbo; |
| #if USE(OPENGL_ES) |
| if (attributes.depth) |
| gl::GenRenderbuffers(1, &m_depthBuffer); |
| if (attributes.stencil) |
| gl::GenRenderbuffers(1, &m_stencilBuffer); |
| #endif |
| if (attributes.stencil || attributes.depth) |
| gl::GenRenderbuffers(1, &m_depthStencilBuffer); |
| } |
| } |
| |
| gl::ClearColor(0, 0, 0, 0); |
| } |
| #else |
| GraphicsContextGLOpenGL::GraphicsContextGLOpenGL(GraphicsContextGLAttributes attributes, HostWindow*, GraphicsContextGLOpenGL::Destination destination, GraphicsContextGLOpenGL* sharedContext) |
| : GraphicsContextGL(attributes, destination, sharedContext) |
| { |
| ASSERT_UNUSED(sharedContext, !sharedContext); |
| #if USE(NICOSIA) |
| m_nicosiaLayer = makeUnique<Nicosia::GC3DLayer>(*this, destination); |
| #else |
| m_texmapLayer = makeUnique<TextureMapperGC3DPlatformLayer>(*this, destination); |
| #endif |
| |
| makeContextCurrent(); |
| |
| validateAttributes(); |
| attributes = contextAttributes(); // They may have changed during validation. |
| |
| if (destination == Destination::Offscreen) { |
| // Create a texture to render into. |
| ::glGenTextures(1, &m_texture); |
| ::glBindTexture(GL_TEXTURE_2D, m_texture); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| ::glBindTexture(GL_TEXTURE_2D, 0); |
| |
| // Create an FBO. |
| ::glGenFramebuffers(1, &m_fbo); |
| ::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| |
| #if USE(COORDINATED_GRAPHICS) |
| ::glGenTextures(1, &m_compositorTexture); |
| ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| ::glGenTextures(1, &m_intermediateTexture); |
| ::glBindTexture(GL_TEXTURE_2D, m_intermediateTexture); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| ::glBindTexture(GL_TEXTURE_2D, 0); |
| #endif |
| |
| // Create a multisample FBO. |
| ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO); |
| if (attributes.antialias) { |
| ::glGenFramebuffers(1, &m_multisampleFBO); |
| ::glBindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); |
| m_state.boundDrawFBO = m_state.boundReadFBO = m_multisampleFBO; |
| ::glGenRenderbuffers(1, &m_multisampleColorBuffer); |
| if (attributes.stencil || attributes.depth) |
| ::glGenRenderbuffers(1, &m_multisampleDepthStencilBuffer); |
| } else { |
| // Bind canvas FBO. |
| glBindFramebuffer(GraphicsContextGLOpenGL::FRAMEBUFFER, m_fbo); |
| m_state.boundDrawFBO = m_state.boundReadFBO = m_fbo; |
| #if USE(OPENGL_ES) |
| if (attributes.depth) |
| glGenRenderbuffers(1, &m_depthBuffer); |
| if (attributes.stencil) |
| glGenRenderbuffers(1, &m_stencilBuffer); |
| #endif |
| if (attributes.stencil || attributes.depth) |
| glGenRenderbuffers(1, &m_depthStencilBuffer); |
| } |
| } |
| |
| #if !USE(OPENGL_ES) |
| ::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); |
| |
| if (GLContext::current()->version() >= 320) { |
| m_usingCoreProfile = true; |
| |
| // From version 3.2 on we use the OpenGL Core profile, so request that ouput to the shader compiler. |
| // OpenGL version 3.2 uses GLSL version 1.50. |
| m_compiler = ANGLEWebKitBridge(SH_GLSL_150_CORE_OUTPUT); |
| |
| // From version 3.2 on we use the OpenGL Core profile, and we need a VAO for rendering. |
| // A VAO could be created and bound by each component using GL rendering (TextureMapper, WebGL, etc). This is |
| // a simpler solution: the first GraphicsContextGLOpenGL created on a GLContext will create and bind a VAO for that context. |
| GCGLint currentVAO = 0; |
| getIntegerv(GraphicsContextGLOpenGL::VERTEX_ARRAY_BINDING, ¤tVAO); |
| if (!currentVAO) { |
| m_vao = createVertexArray(); |
| bindVertexArray(m_vao); |
| } |
| } else { |
| // For lower versions request the compatibility output to the shader compiler. |
| m_compiler = ANGLEWebKitBridge(SH_GLSL_COMPATIBILITY_OUTPUT); |
| |
| // GL_POINT_SPRITE is needed in lower versions. |
| ::glEnable(GL_POINT_SPRITE); |
| } |
| #else |
| // Adjust the shader specification depending on whether GLES3 (i.e. WebGL2 support) was requested. |
| m_compiler = ANGLEWebKitBridge(SH_ESSL_OUTPUT, attributes.isWebGL2 ? SH_WEBGL2_SPEC : SH_WEBGL_SPEC); |
| #endif |
| |
| // ANGLE initialization. |
| ShBuiltInResources ANGLEResources; |
| sh::InitBuiltInResources(&ANGLEResources); |
| |
| getIntegerv(GraphicsContextGLOpenGL::MAX_VERTEX_ATTRIBS, &ANGLEResources.MaxVertexAttribs); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_VERTEX_UNIFORM_VECTORS, &ANGLEResources.MaxVertexUniformVectors); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_VARYING_VECTORS, &ANGLEResources.MaxVaryingVectors); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_VERTEX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxVertexTextureImageUnits); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxCombinedTextureImageUnits); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxTextureImageUnits); |
| getIntegerv(GraphicsContextGLOpenGL::MAX_FRAGMENT_UNIFORM_VECTORS, &ANGLEResources.MaxFragmentUniformVectors); |
| |
| // Always set to 1 for OpenGL ES. |
| ANGLEResources.MaxDrawBuffers = 1; |
| |
| GCGLint range[2], precision; |
| getShaderPrecisionFormat(GraphicsContextGLOpenGL::FRAGMENT_SHADER, GraphicsContextGLOpenGL::HIGH_FLOAT, range, &precision); |
| ANGLEResources.FragmentPrecisionHigh = (range[0] || range[1] || precision); |
| |
| m_compiler.setResources(ANGLEResources); |
| |
| ::glClearColor(0, 0, 0, 0); |
| } |
| #endif |
| |
| #if USE(ANGLE) |
| GraphicsContextGLOpenGL::~GraphicsContextGLOpenGL() |
| { |
| makeContextCurrent(); |
| if (m_texture) |
| gl::DeleteTextures(1, &m_texture); |
| #if USE(COORDINATED_GRAPHICS) |
| if (m_compositorTexture) |
| gl::DeleteTextures(1, &m_compositorTexture); |
| #endif |
| |
| auto attributes = contextAttributes(); |
| |
| if (attributes.antialias) { |
| gl::DeleteRenderbuffers(1, &m_multisampleColorBuffer); |
| if (attributes.stencil || attributes.depth) |
| gl::DeleteRenderbuffers(1, &m_multisampleDepthStencilBuffer); |
| gl::DeleteFramebuffers(1, &m_multisampleFBO); |
| } else if (attributes.stencil || attributes.depth) { |
| #if USE(OPENGL_ES) |
| if (m_depthBuffer) |
| glDeleteRenderbuffers(1, &m_depthBuffer); |
| |
| if (m_stencilBuffer) |
| glDeleteRenderbuffers(1, &m_stencilBuffer); |
| #endif |
| if (m_depthStencilBuffer) |
| gl::DeleteRenderbuffers(1, &m_depthStencilBuffer); |
| } |
| gl::DeleteFramebuffers(1, &m_fbo); |
| #if USE(COORDINATED_GRAPHICS) |
| gl::DeleteTextures(1, &m_intermediateTexture); |
| #endif |
| |
| #if USE(CAIRO) |
| if (m_vao) |
| deleteVertexArray(m_vao); |
| #endif |
| |
| auto* activeContext = activeContexts().takeLast([this](auto* it) { |
| return it == this; |
| }); |
| ASSERT_UNUSED(activeContext, !!activeContext); |
| } |
| #else |
| GraphicsContextGLOpenGL::~GraphicsContextGLOpenGL() |
| { |
| makeContextCurrent(); |
| if (m_texture) |
| ::glDeleteTextures(1, &m_texture); |
| #if USE(COORDINATED_GRAPHICS) |
| if (m_compositorTexture) |
| ::glDeleteTextures(1, &m_compositorTexture); |
| #endif |
| |
| auto attributes = contextAttributes(); |
| |
| if (attributes.antialias) { |
| ::glDeleteRenderbuffers(1, &m_multisampleColorBuffer); |
| if (attributes.stencil || attributes.depth) |
| ::glDeleteRenderbuffers(1, &m_multisampleDepthStencilBuffer); |
| ::glDeleteFramebuffers(1, &m_multisampleFBO); |
| } else if (attributes.stencil || attributes.depth) { |
| #if USE(OPENGL_ES) |
| if (m_depthBuffer) |
| glDeleteRenderbuffers(1, &m_depthBuffer); |
| |
| if (m_stencilBuffer) |
| glDeleteRenderbuffers(1, &m_stencilBuffer); |
| #endif |
| if (m_depthStencilBuffer) |
| ::glDeleteRenderbuffers(1, &m_depthStencilBuffer); |
| } |
| ::glDeleteFramebuffers(1, &m_fbo); |
| #if USE(COORDINATED_GRAPHICS) |
| ::glDeleteTextures(1, &m_intermediateTexture); |
| #endif |
| |
| #if USE(CAIRO) |
| if (m_vao) |
| deleteVertexArray(m_vao); |
| #endif |
| |
| auto* activeContext = activeContexts().takeLast([this](auto* it) { |
| return it == this; |
| }); |
| ASSERT_UNUSED(activeContext, !!activeContext); |
| } |
| #endif // USE(ANGLE) |
| |
| bool GraphicsContextGLOpenGL::makeContextCurrent() |
| { |
| #if USE(NICOSIA) |
| return m_nicosiaLayer->makeContextCurrent(); |
| #else |
| return m_texmapLayer->makeContextCurrent(); |
| #endif |
| } |
| |
| void GraphicsContextGLOpenGL::checkGPUStatus() |
| { |
| } |
| |
| PlatformGraphicsContextGL GraphicsContextGLOpenGL::platformGraphicsContextGL() const |
| { |
| #if USE(NICOSIA) |
| return m_nicosiaLayer->platformContext(); |
| #else |
| return m_texmapLayer->platformContext(); |
| #endif |
| } |
| |
| PlatformGLObject GraphicsContextGLOpenGL::platformTexture() const |
| { |
| return m_texture; |
| } |
| |
| bool GraphicsContextGLOpenGL::isGLES2Compliant() const |
| { |
| #if USE(OPENGL_ES) |
| return true; |
| #else |
| return false; |
| #endif |
| } |
| |
| PlatformLayer* GraphicsContextGLOpenGL::platformLayer() const |
| { |
| #if USE(NICOSIA) |
| return &m_nicosiaLayer->contentLayer(); |
| #else |
| return m_texmapLayer.get(); |
| #endif |
| } |
| |
| #if PLATFORM(GTK) && !USE(ANGLE) |
| ExtensionsGL& GraphicsContextGLOpenGL::getExtensions() |
| { |
| if (!m_extensions) { |
| #if USE(OPENGL_ES) |
| // glGetStringi is not available on GLES2. |
| m_extensions = makeUnique<ExtensionsGLOpenGLES>(this, false); |
| #else |
| // From OpenGL 3.2 on we use the Core profile, and there we must use glGetStringi. |
| m_extensions = makeUnique<ExtensionsGLOpenGL>(this, GLContext::current()->version() >= 320); |
| #endif |
| } |
| return *m_extensions; |
| } |
| #endif |
| |
| } // namespace WebCore |
| |
| #endif // ENABLE(GRAPHICS_CONTEXT_GL) && USE(TEXTURE_MAPPER) |