--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/chromium/src/WebGraphicsContext3DDefaultImpl.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,1508 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 THE COPYRIGHT
+ * OWNER 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"
+
+#if ENABLE(3D_CANVAS)
+
+#include <stdio.h>
+#include <string.h>
+
+#include "WebGraphicsContext3DDefaultImpl.h"
+
+#include "NotImplemented.h"
+
+#if OS(LINUX)
+#include <dlfcn.h>
+#endif
+
+namespace WebKit {
+
+// Uncomment this to render to a separate window for debugging
+// #define RENDER_TO_DEBUGGING_WINDOW
+
+#if OS(DARWIN)
+#define USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER
+#endif
+
+bool WebGraphicsContext3DDefaultImpl::s_initializedGLEW = false;
+
+#if OS(LINUX)
+WebGraphicsContext3DDefaultImpl::GLConnection* WebGraphicsContext3DDefaultImpl::s_gl = 0;
+
+WebGraphicsContext3DDefaultImpl::GLConnection* WebGraphicsContext3DDefaultImpl::GLConnection::create()
+{
+ Display* dpy = XOpenDisplay(0);
+ if (!dpy) {
+ printf("GraphicsContext3D: error opening X display\n");
+ return 0;
+ }
+
+ // We use RTLD_GLOBAL semantics so that GLEW initialization works;
+ // GLEW expects to be able to open the current process's handle
+ // and do dlsym's of GL entry points from there.
+ void* libGL = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL);
+ if (!libGL) {
+ XCloseDisplay(dpy);
+ printf("GraphicsContext3D: error opening libGL.so.1: %s\n", dlerror());
+ return 0;
+ }
+
+ PFNGLXCHOOSEFBCONFIGPROC chooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) dlsym(libGL, "glXChooseFBConfig");
+ PFNGLXCREATENEWCONTEXTPROC createNewContext = (PFNGLXCREATENEWCONTEXTPROC) dlsym(libGL, "glXCreateNewContext");
+ PFNGLXCREATEPBUFFERPROC createPbuffer = (PFNGLXCREATEPBUFFERPROC) dlsym(libGL, "glXCreatePbuffer");
+ PFNGLXDESTROYPBUFFERPROC destroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) dlsym(libGL, "glXDestroyPbuffer");
+ PFNGLXMAKECURRENTPROC makeCurrent = (PFNGLXMAKECURRENTPROC) dlsym(libGL, "glXMakeCurrent");
+ PFNGLXDESTROYCONTEXTPROC destroyContext = (PFNGLXDESTROYCONTEXTPROC) dlsym(libGL, "glXDestroyContext");
+ PFNGLXGETCURRENTCONTEXTPROC getCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) dlsym(libGL, "glXGetCurrentContext");
+ if (!chooseFBConfig || !createNewContext || !createPbuffer
+ || !destroyPbuffer || !makeCurrent || !destroyContext
+ || !getCurrentContext) {
+ XCloseDisplay(dpy);
+ dlclose(libGL);
+ printf("GraphicsContext3D: error looking up bootstrapping entry points\n");
+ return 0;
+ }
+ return new GLConnection(dpy,
+ libGL,
+ chooseFBConfig,
+ createNewContext,
+ createPbuffer,
+ destroyPbuffer,
+ makeCurrent,
+ destroyContext,
+ getCurrentContext);
+}
+
+WebGraphicsContext3DDefaultImpl::GLConnection::~GLConnection()
+{
+ XCloseDisplay(m_display);
+ dlclose(m_libGL);
+}
+
+#endif // OS(LINUX)
+
+WebGraphicsContext3DDefaultImpl::VertexAttribPointerState::VertexAttribPointerState()
+ : enabled(false)
+ , buffer(0)
+ , indx(0)
+ , size(0)
+ , type(0)
+ , normalized(false)
+ , stride(0)
+ , offset(0)
+{
+}
+
+WebGraphicsContext3DDefaultImpl::WebGraphicsContext3DDefaultImpl()
+ : m_initialized(false)
+ , m_texture(0)
+ , m_fbo(0)
+ , m_depthStencilBuffer(0)
+ , m_multisampleFBO(0)
+ , m_multisampleDepthStencilBuffer(0)
+ , m_multisampleColorBuffer(0)
+ , m_boundFBO(0)
+#ifdef FLIP_FRAMEBUFFER_VERTICALLY
+ , m_scanline(0)
+#endif
+ , m_boundArrayBuffer(0)
+#if OS(WINDOWS)
+ , m_canvasWindow(0)
+ , m_canvasDC(0)
+ , m_contextObj(0)
+#elif PLATFORM(CG)
+ , m_pbuffer(0)
+ , m_contextObj(0)
+ , m_renderOutput(0)
+#elif OS(LINUX)
+ , m_contextObj(0)
+ , m_pbuffer(0)
+#else
+#error Must port to your platform
+#endif
+{
+}
+
+WebGraphicsContext3DDefaultImpl::~WebGraphicsContext3DDefaultImpl()
+{
+ if (m_initialized) {
+ makeContextCurrent();
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias) {
+ glDeleteRenderbuffersEXT(1, &m_multisampleColorBuffer);
+ if (m_attributes.depth || m_attributes.stencil)
+ glDeleteRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
+ glDeleteFramebuffersEXT(1, &m_multisampleFBO);
+ } else {
+ if (m_attributes.depth || m_attributes.stencil)
+ glDeleteRenderbuffersEXT(1, &m_depthStencilBuffer);
+ }
+ glDeleteTextures(1, &m_texture);
+#ifdef FLIP_FRAMEBUFFER_VERTICALLY
+ if (m_scanline)
+ delete[] m_scanline;
+#endif
+ glDeleteFramebuffersEXT(1, &m_fbo);
+#endif // !RENDER_TO_DEBUGGING_WINDOW
+#if OS(WINDOWS)
+ wglewMakeCurrent(0, 0);
+ wglewDeleteContext(m_contextObj);
+ ReleaseDC(m_canvasWindow, m_canvasDC);
+ DestroyWindow(m_canvasWindow);
+#elif PLATFORM(CG)
+ CGLSetCurrentContext(0);
+ CGLDestroyContext(m_contextObj);
+ CGLDestroyPBuffer(m_pbuffer);
+ if (m_renderOutput)
+ delete[] m_renderOutput;
+#elif OS(LINUX)
+ s_gl->makeCurrent(0, 0);
+ s_gl->destroyContext(m_contextObj);
+ s_gl->destroyPbuffer(m_pbuffer);
+#else
+#error Must port to your platform
+#endif
+ m_contextObj = 0;
+ }
+}
+
+bool WebGraphicsContext3DDefaultImpl::initialize(WebGraphicsContext3D::Attributes attributes, WebView* webView)
+{
+#if OS(WINDOWS)
+ if (!s_initializedGLEW) {
+ // Do this only the first time through.
+ if (!wglewInit()) {
+ printf("WebGraphicsContext3DDefaultImpl: wglewInit failed\n");
+ return false;
+ }
+ }
+
+ WNDCLASS wc;
+ if (!GetClassInfo(GetModuleHandle(0), L"CANVASGL", &wc)) {
+ ZeroMemory(&wc, sizeof(WNDCLASS));
+ wc.style = CS_OWNDC;
+ wc.hInstance = GetModuleHandle(0);
+ wc.lpfnWndProc = DefWindowProc;
+ wc.lpszClassName = L"CANVASGL";
+
+ if (!RegisterClass(&wc)) {
+ printf("WebGraphicsContext3DDefaultImpl: RegisterClass failed\n");
+ return false;
+ }
+ }
+
+ m_canvasWindow = CreateWindow(L"CANVASGL", L"CANVASGL",
+ WS_CAPTION,
+ CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+ CW_USEDEFAULT, 0, 0, GetModuleHandle(0), 0);
+ if (!m_canvasWindow) {
+ printf("WebGraphicsContext3DDefaultImpl: CreateWindow failed\n");
+ return false;
+ }
+
+ // get the device context
+ m_canvasDC = GetDC(m_canvasWindow);
+ if (!m_canvasDC) {
+ printf("WebGraphicsContext3DDefaultImpl: GetDC failed\n");
+ return false;
+ }
+
+ // find default pixel format
+ PIXELFORMATDESCRIPTOR pfd;
+ ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
+ pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
+ pfd.nVersion = 1;
+#ifdef RENDER_TO_DEBUGGING_WINDOW
+ pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+#else
+ pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
+#endif
+ int pixelformat = ChoosePixelFormat(m_canvasDC, &pfd);
+
+ // set the pixel format for the dc
+ if (!SetPixelFormat(m_canvasDC, pixelformat, &pfd)) {
+ printf("WebGraphicsContext3DDefaultImpl: SetPixelFormat failed\n");
+ return false;
+ }
+
+ // create rendering context
+ m_contextObj = wglewCreateContext(m_canvasDC);
+ if (!m_contextObj) {
+ printf("WebGraphicsContext3DDefaultImpl: wglCreateContext failed\n");
+ return false;
+ }
+
+ if (!wglewMakeCurrent(m_canvasDC, m_contextObj)) {
+ printf("WebGraphicsContext3DDefaultImpl: wglMakeCurrent failed\n");
+ return false;
+ }
+
+#ifdef RENDER_TO_DEBUGGING_WINDOW
+ typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
+ PFNWGLSWAPINTERVALEXTPROC setSwapInterval = 0;
+ setSwapInterval = (PFNWGLSWAPINTERVALEXTPROC) wglewGetProcAddress("wglSwapIntervalEXT");
+ if (setSwapInterval)
+ setSwapInterval(1);
+#endif // RENDER_TO_DEBUGGING_WINDOW
+
+#elif PLATFORM(CG)
+ // Create a 1x1 pbuffer and associated context to bootstrap things
+ CGLPixelFormatAttribute attribs[] = {
+ (CGLPixelFormatAttribute) kCGLPFAPBuffer,
+ (CGLPixelFormatAttribute) 0
+ };
+ CGLPixelFormatObj pixelFormat;
+ GLint numPixelFormats;
+ if (CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats) != kCGLNoError) {
+ printf("WebGraphicsContext3DDefaultImpl: error choosing pixel format\n");
+ return false;
+ }
+ if (!pixelFormat) {
+ printf("WebGraphicsContext3DDefaultImpl: no pixel format selected\n");
+ return false;
+ }
+ CGLContextObj context;
+ CGLError res = CGLCreateContext(pixelFormat, 0, &context);
+ CGLDestroyPixelFormat(pixelFormat);
+ if (res != kCGLNoError) {
+ printf("WebGraphicsContext3DDefaultImpl: error creating context\n");
+ return false;
+ }
+ CGLPBufferObj pbuffer;
+ if (CGLCreatePBuffer(1, 1, GL_TEXTURE_2D, GL_RGBA, 0, &pbuffer) != kCGLNoError) {
+ CGLDestroyContext(context);
+ printf("WebGraphicsContext3DDefaultImpl: error creating pbuffer\n");
+ return false;
+ }
+ if (CGLSetPBuffer(context, pbuffer, 0, 0, 0) != kCGLNoError) {
+ CGLDestroyContext(context);
+ CGLDestroyPBuffer(pbuffer);
+ printf("WebGraphicsContext3DDefaultImpl: error attaching pbuffer to context\n");
+ return false;
+ }
+ if (CGLSetCurrentContext(context) != kCGLNoError) {
+ CGLDestroyContext(context);
+ CGLDestroyPBuffer(pbuffer);
+ printf("WebGraphicsContext3DDefaultImpl: error making context current\n");
+ return false;
+ }
+ m_pbuffer = pbuffer;
+ m_contextObj = context;
+#elif OS(LINUX)
+ if (!s_gl) {
+ s_gl = GLConnection::create();
+ if (!s_gl)
+ return false;
+ }
+
+ int configAttrs[] = {
+ GLX_DRAWABLE_TYPE,
+ GLX_PBUFFER_BIT,
+ GLX_RENDER_TYPE,
+ GLX_RGBA_BIT,
+ GLX_DOUBLEBUFFER,
+ 0,
+ 0
+ };
+ int nelements = 0;
+ GLXFBConfig* config = s_gl->chooseFBConfig(0, configAttrs, &nelements);
+ if (!config) {
+ printf("WebGraphicsContext3DDefaultImpl: glXChooseFBConfig failed\n");
+ return false;
+ }
+ if (!nelements) {
+ printf("WebGraphicsContext3DDefaultImpl: glXChooseFBConfig returned 0 elements\n");
+ XFree(config);
+ return false;
+ }
+ GLXContext context = s_gl->createNewContext(config[0], GLX_RGBA_TYPE, 0, True);
+ if (!context) {
+ printf("WebGraphicsContext3DDefaultImpl: glXCreateNewContext failed\n");
+ XFree(config);
+ return false;
+ }
+ int pbufferAttrs[] = {
+ GLX_PBUFFER_WIDTH,
+ 1,
+ GLX_PBUFFER_HEIGHT,
+ 1,
+ 0
+ };
+ GLXPbuffer pbuffer = s_gl->createPbuffer(config[0], pbufferAttrs);
+ XFree(config);
+ if (!pbuffer) {
+ printf("WebGraphicsContext3DDefaultImpl: glxCreatePbuffer failed\n");
+ return false;
+ }
+ if (!s_gl->makeCurrent(pbuffer, context)) {
+ printf("WebGraphicsContext3DDefaultImpl: glXMakeCurrent failed\n");
+ return false;
+ }
+ m_contextObj = context;
+ m_pbuffer = pbuffer;
+#else
+#error Must port to your platform
+#endif
+
+ if (!s_initializedGLEW) {
+ // Initialize GLEW and check for GL 2.0 support by the drivers.
+ GLenum glewInitResult = glewInit();
+ if (glewInitResult != GLEW_OK) {
+ printf("WebGraphicsContext3DDefaultImpl: GLEW initialization failed\n");
+ return false;
+ }
+ if (!glewIsSupported("GL_VERSION_2_0")) {
+ printf("WebGraphicsContext3DDefaultImpl: OpenGL 2.0 not supported\n");
+ return false;
+ }
+ s_initializedGLEW = true;
+ }
+
+ m_attributes = attributes;
+ validateAttributes();
+
+ glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
+ m_initialized = true;
+ return true;
+}
+
+void WebGraphicsContext3DDefaultImpl::validateAttributes()
+{
+ const char* extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+
+ if (m_attributes.stencil) {
+ if (strstr(extensions, "GL_EXT_packed_depth_stencil")) {
+ if (!m_attributes.depth)
+ m_attributes.depth = true;
+ } else
+ m_attributes.stencil = false;
+ }
+ if (m_attributes.antialias) {
+ bool isValidVendor = true;
+#if PLATFORM(CG)
+ // Currently in Mac we only turn on antialias if vendor is NVIDIA.
+ const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
+ if (!strstr(vendor, "NVIDIA"))
+ isValidVendor = false;
+#endif
+ if (!isValidVendor || !strstr(extensions, "GL_EXT_framebuffer_multisample"))
+ m_attributes.antialias = false;
+ }
+ // FIXME: instead of enforcing premultipliedAlpha = true, implement the
+ // correct behavior when premultipliedAlpha = false is requested.
+ m_attributes.premultipliedAlpha = true;
+}
+
+bool WebGraphicsContext3DDefaultImpl::makeContextCurrent()
+{
+#if OS(WINDOWS)
+ if (wglewGetCurrentContext() != m_contextObj)
+ if (wglewMakeCurrent(m_canvasDC, m_contextObj))
+ return true;
+#elif PLATFORM(CG)
+ if (CGLGetCurrentContext() != m_contextObj)
+ if (CGLSetCurrentContext(m_contextObj) == kCGLNoError)
+ return true;
+#elif OS(LINUX)
+ if (s_gl->getCurrentContext() != m_contextObj)
+ if (s_gl->makeCurrent(m_pbuffer, m_contextObj))
+ return true;
+#else
+#error Must port to your platform
+#endif
+ return false;
+}
+
+int WebGraphicsContext3DDefaultImpl::width()
+{
+ return m_cachedWidth;
+}
+
+int WebGraphicsContext3DDefaultImpl::height()
+{
+ return m_cachedHeight;
+}
+
+int WebGraphicsContext3DDefaultImpl::sizeInBytes(int type)
+{
+ switch (type) {
+ case GL_BYTE:
+ return sizeof(GLbyte);
+ case GL_UNSIGNED_BYTE:
+ return sizeof(GLubyte);
+ case GL_SHORT:
+ return sizeof(GLshort);
+ case GL_UNSIGNED_SHORT:
+ return sizeof(GLushort);
+ case GL_INT:
+ return sizeof(GLint);
+ case GL_UNSIGNED_INT:
+ return sizeof(GLuint);
+ case GL_FLOAT:
+ return sizeof(GLfloat);
+ }
+ return 0;
+}
+
+bool WebGraphicsContext3DDefaultImpl::isGLES2Compliant()
+{
+ return false;
+}
+
+unsigned int WebGraphicsContext3DDefaultImpl::getPlatformTextureId()
+{
+ ASSERT_NOT_REACHED();
+ return 0;
+}
+
+void WebGraphicsContext3DDefaultImpl::prepareTexture()
+{
+ ASSERT_NOT_REACHED();
+}
+
+static int createTextureObject(GLenum target)
+{
+ GLuint texture = 0;
+ glGenTextures(1, &texture);
+ glBindTexture(target, texture);
+ glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ return texture;
+}
+
+void WebGraphicsContext3DDefaultImpl::reshape(int width, int height)
+{
+#ifdef RENDER_TO_DEBUGGING_WINDOW
+ SetWindowPos(m_canvasWindow, HWND_TOP, 0, 0, width, height,
+ SWP_NOMOVE);
+ ShowWindow(m_canvasWindow, SW_SHOW);
+#endif
+
+ m_cachedWidth = width;
+ m_cachedHeight = height;
+ makeContextCurrent();
+
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+#ifdef USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER
+ // GL_TEXTURE_RECTANGLE_ARB is the best supported render target on Mac OS X
+ GLenum target = GL_TEXTURE_RECTANGLE_ARB;
+#else
+ GLenum target = GL_TEXTURE_2D;
+#endif
+ if (!m_texture) {
+ // Generate the texture object
+ m_texture = createTextureObject(target);
+ // Generate the framebuffer object
+ glGenFramebuffersEXT(1, &m_fbo);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ m_boundFBO = m_fbo;
+ if (m_attributes.depth || m_attributes.stencil)
+ glGenRenderbuffersEXT(1, &m_depthStencilBuffer);
+ // Generate the multisample framebuffer object
+ if (m_attributes.antialias) {
+ glGenFramebuffersEXT(1, &m_multisampleFBO);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
+ m_boundFBO = m_multisampleFBO;
+ glGenRenderbuffersEXT(1, &m_multisampleColorBuffer);
+ if (m_attributes.depth || m_attributes.stencil)
+ glGenRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
+ }
+ }
+
+ GLint internalColorFormat, colorFormat, internalDepthStencilFormat = 0;
+ if (m_attributes.alpha) {
+ internalColorFormat = GL_RGBA8;
+ colorFormat = GL_RGBA;
+ } else {
+ internalColorFormat = GL_RGB8;
+ colorFormat = GL_RGB;
+ }
+ if (m_attributes.stencil || m_attributes.depth) {
+ // We don't allow the logic where stencil is required and depth is not.
+ // See GraphicsContext3DInternal constructor.
+ if (m_attributes.stencil && m_attributes.depth)
+ internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
+ else
+ internalDepthStencilFormat = GL_DEPTH_COMPONENT;
+ }
+
+ bool mustRestoreFBO = false;
+
+ // Resize multisampling FBO
+ if (m_attributes.antialias) {
+ GLint maxSampleCount;
+ glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount);
+ GLint sampleCount = std::min(8, maxSampleCount);
+ if (m_boundFBO != m_multisampleFBO) {
+ mustRestoreFBO = true;
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
+ }
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
+ glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalColorFormat, width, height);
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
+ if (m_attributes.stencil || m_attributes.depth) {
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
+ glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height);
+ if (m_attributes.stencil)
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
+ if (m_attributes.depth)
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
+ }
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+ GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+ printf("GraphicsContext3D: multisampling framebuffer was incomplete\n");
+
+ // FIXME: cleanup.
+ notImplemented();
+ }
+ }
+
+ // Resize regular FBO
+ if (m_boundFBO != m_fbo) {
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ mustRestoreFBO = true;
+ }
+ glBindTexture(target, m_texture);
+ glTexImage2D(target, 0, internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
+ glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, m_texture, 0);
+ glBindTexture(target, 0);
+ if (!m_attributes.antialias && (m_attributes.stencil || m_attributes.depth)) {
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
+ glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
+ if (m_attributes.stencil)
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
+ if (m_attributes.depth)
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+ }
+ GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+ printf("WebGraphicsContext3DDefaultImpl: framebuffer was incomplete\n");
+
+ // FIXME: cleanup.
+ notImplemented();
+ }
+
+ if (m_attributes.antialias) {
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
+ if (m_boundFBO == m_multisampleFBO)
+ mustRestoreFBO = false;
+ }
+
+ // Initialize renderbuffers to 0.
+ GLboolean colorMask[] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE}, depthMask = GL_TRUE, stencilMask = GL_TRUE;
+ GLboolean isScissorEnabled = GL_FALSE;
+ GLboolean isDitherEnabled = GL_FALSE;
+ GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
+ glGetBooleanv(GL_COLOR_WRITEMASK, colorMask);
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ if (m_attributes.depth) {
+ glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask);
+ glDepthMask(GL_TRUE);
+ clearMask |= GL_DEPTH_BUFFER_BIT;
+ }
+ if (m_attributes.stencil) {
+ glGetBooleanv(GL_STENCIL_WRITEMASK, &stencilMask);
+ glStencilMask(GL_TRUE);
+ clearMask |= GL_STENCIL_BUFFER_BIT;
+ }
+ isScissorEnabled = glIsEnabled(GL_SCISSOR_TEST);
+ glDisable(GL_SCISSOR_TEST);
+ isDitherEnabled = glIsEnabled(GL_DITHER);
+ glDisable(GL_DITHER);
+
+ glClear(clearMask);
+
+ glColorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);
+ if (m_attributes.depth)
+ glDepthMask(depthMask);
+ if (m_attributes.stencil)
+ glStencilMask(stencilMask);
+ if (isScissorEnabled)
+ glEnable(GL_SCISSOR_TEST);
+ else
+ glDisable(GL_SCISSOR_TEST);
+ if (isDitherEnabled)
+ glEnable(GL_DITHER);
+ else
+ glDisable(GL_DITHER);
+
+ if (mustRestoreFBO)
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
+#endif // RENDER_TO_DEBUGGING_WINDOW
+
+#ifdef FLIP_FRAMEBUFFER_VERTICALLY
+ if (m_scanline) {
+ delete[] m_scanline;
+ m_scanline = 0;
+ }
+ m_scanline = new unsigned char[width * 4];
+#endif // FLIP_FRAMEBUFFER_VERTICALLY
+}
+
+#ifdef FLIP_FRAMEBUFFER_VERTICALLY
+void WebGraphicsContext3DDefaultImpl::flipVertically(unsigned char* framebuffer,
+ unsigned int width,
+ unsigned int height)
+{
+ unsigned char* scanline = m_scanline;
+ if (!scanline)
+ return;
+ unsigned int rowBytes = width * 4;
+ unsigned int count = height / 2;
+ for (unsigned int i = 0; i < count; i++) {
+ unsigned char* rowA = framebuffer + i * rowBytes;
+ unsigned char* rowB = framebuffer + (height - i - 1) * rowBytes;
+ // FIXME: this is where the multiplication of the alpha
+ // channel into the color buffer will need to occur if the
+ // user specifies the "premultiplyAlpha" flag in the context
+ // creation attributes.
+ memcpy(scanline, rowB, rowBytes);
+ memcpy(rowB, rowA, rowBytes);
+ memcpy(rowA, scanline, rowBytes);
+ }
+}
+#endif
+
+bool WebGraphicsContext3DDefaultImpl::readBackFramebuffer(unsigned char* pixels, size_t bufferSize)
+{
+ if (bufferSize != static_cast<size_t>(4 * width() * height()))
+ return false;
+
+ makeContextCurrent();
+
+#ifdef RENDER_TO_DEBUGGING_WINDOW
+ SwapBuffers(m_canvasDC);
+#else
+ // Earlier versions of this code used the GPU to flip the
+ // framebuffer vertically before reading it back for compositing
+ // via software. This code was quite complicated, used a lot of
+ // GPU memory, and didn't provide an obvious speedup. Since this
+ // vertical flip is only a temporary solution anyway until Chrome
+ // is fully GPU composited, it wasn't worth the complexity.
+
+ bool mustRestoreFBO = false;
+ if (m_attributes.antialias) {
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
+ glBlitFramebufferEXT(0, 0, m_cachedWidth, m_cachedHeight, 0, 0, m_cachedWidth, m_cachedHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ mustRestoreFBO = true;
+ } else {
+ if (m_boundFBO != m_fbo) {
+ mustRestoreFBO = true;
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ }
+ }
+
+ GLint packAlignment = 4;
+ bool mustRestorePackAlignment = false;
+ glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment);
+ if (packAlignment > 4) {
+ glPixelStorei(GL_PACK_ALIGNMENT, 4);
+ mustRestorePackAlignment = true;
+ }
+
+#if PLATFORM(SKIA)
+ glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
+#elif PLATFORM(CG)
+ glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
+#else
+#error Must port to your platform
+#endif
+
+ if (mustRestorePackAlignment)
+ glPixelStorei(GL_PACK_ALIGNMENT, packAlignment);
+
+ if (mustRestoreFBO)
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
+
+#ifdef FLIP_FRAMEBUFFER_VERTICALLY
+ if (pixels)
+ flipVertically(pixels, m_cachedWidth, m_cachedHeight);
+#endif
+
+#endif // RENDER_TO_DEBUGGING_WINDOW
+ return true;
+}
+
+void WebGraphicsContext3DDefaultImpl::synthesizeGLError(unsigned long error)
+{
+ m_syntheticErrors.add(error);
+}
+
+// Helper macros to reduce the amount of code.
+
+#define DELEGATE_TO_GL(name, glname) \
+void WebGraphicsContext3DDefaultImpl::name() \
+{ \
+ makeContextCurrent(); \
+ gl##glname(); \
+}
+
+#define DELEGATE_TO_GL_1(name, glname, t1) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1); \
+}
+
+#define DELEGATE_TO_GL_1R(name, glname, t1, rt) \
+rt WebGraphicsContext3DDefaultImpl::name(t1 a1) \
+{ \
+ makeContextCurrent(); \
+ return gl##glname(a1); \
+}
+
+#define DELEGATE_TO_GL_2(name, glname, t1, t2) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2); \
+}
+
+#define DELEGATE_TO_GL_2R(name, glname, t1, t2, rt) \
+rt WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2) \
+{ \
+ makeContextCurrent(); \
+ return gl##glname(a1, a2); \
+}
+
+#define DELEGATE_TO_GL_3(name, glname, t1, t2, t3) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3); \
+}
+
+#define DELEGATE_TO_GL_4(name, glname, t1, t2, t3, t4) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4); \
+}
+
+#define DELEGATE_TO_GL_5(name, glname, t1, t2, t3, t4, t5) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4, a5); \
+}
+
+#define DELEGATE_TO_GL_6(name, glname, t1, t2, t3, t4, t5, t6) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4, a5, a6); \
+}
+
+#define DELEGATE_TO_GL_7(name, glname, t1, t2, t3, t4, t5, t6, t7) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4, a5, a6, a7); \
+}
+
+#define DELEGATE_TO_GL_8(name, glname, t1, t2, t3, t4, t5, t6, t7, t8) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7, t8 a8) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4, a5, a6, a7, a8); \
+}
+
+#define DELEGATE_TO_GL_9(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, t9) \
+void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7, t8 a8, t9 a9) \
+{ \
+ makeContextCurrent(); \
+ gl##glname(a1, a2, a3, a4, a5, a6, a7, a8, a9); \
+}
+
+void WebGraphicsContext3DDefaultImpl::activeTexture(unsigned long texture)
+{
+ // FIXME: query number of textures available.
+ if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0+32)
+ // FIXME: raise exception.
+ return;
+
+ makeContextCurrent();
+ glActiveTexture(texture);
+}
+
+DELEGATE_TO_GL_2(attachShader, AttachShader, WebGLId, WebGLId)
+
+DELEGATE_TO_GL_3(bindAttribLocation, BindAttribLocation, WebGLId, unsigned long, const char*)
+
+void WebGraphicsContext3DDefaultImpl::bindBuffer(unsigned long target, WebGLId buffer)
+{
+ makeContextCurrent();
+ if (target == GL_ARRAY_BUFFER)
+ m_boundArrayBuffer = buffer;
+ glBindBuffer(target, buffer);
+}
+
+void WebGraphicsContext3DDefaultImpl::bindFramebuffer(unsigned long target, WebGLId framebuffer)
+{
+ makeContextCurrent();
+ if (!framebuffer)
+ framebuffer = (m_attributes.antialias ? m_multisampleFBO : m_fbo);
+ if (framebuffer != m_boundFBO) {
+ glBindFramebufferEXT(target, framebuffer);
+ m_boundFBO = framebuffer;
+ }
+}
+
+DELEGATE_TO_GL_2(bindRenderbuffer, BindRenderbufferEXT, unsigned long, WebGLId)
+
+DELEGATE_TO_GL_2(bindTexture, BindTexture, unsigned long, WebGLId)
+
+DELEGATE_TO_GL_4(blendColor, BlendColor, double, double, double, double)
+
+DELEGATE_TO_GL_1(blendEquation, BlendEquation, unsigned long)
+
+DELEGATE_TO_GL_2(blendEquationSeparate, BlendEquationSeparate, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_2(blendFunc, BlendFunc, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_4(blendFuncSeparate, BlendFuncSeparate, unsigned long, unsigned long, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_4(bufferData, BufferData, unsigned long, int, const void*, unsigned long)
+
+DELEGATE_TO_GL_4(bufferSubData, BufferSubData, unsigned long, long, int, const void*)
+
+DELEGATE_TO_GL_1R(checkFramebufferStatus, CheckFramebufferStatusEXT, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_1(clear, Clear, unsigned long)
+
+DELEGATE_TO_GL_4(clearColor, ClearColor, double, double, double, double)
+
+DELEGATE_TO_GL_1(clearDepth, ClearDepth, double)
+
+DELEGATE_TO_GL_1(clearStencil, ClearStencil, long)
+
+DELEGATE_TO_GL_4(colorMask, ColorMask, bool, bool, bool, bool)
+
+DELEGATE_TO_GL_1(compileShader, CompileShader, WebGLId)
+
+void WebGraphicsContext3DDefaultImpl::copyTexImage2D(unsigned long target, long level, unsigned long internalformat,
+ long x, long y, unsigned long width, unsigned long height, long border)
+{
+ makeContextCurrent();
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
+ glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ }
+#endif
+ glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
+#endif
+}
+
+void WebGraphicsContext3DDefaultImpl::copyTexSubImage2D(unsigned long target, long level, long xoffset, long yoffset,
+ long x, long y, unsigned long width, unsigned long height)
+{
+ makeContextCurrent();
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
+ glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ }
+#endif
+ glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
+#endif
+}
+
+DELEGATE_TO_GL_1(cullFace, CullFace, unsigned long)
+
+DELEGATE_TO_GL_1(depthFunc, DepthFunc, unsigned long)
+
+DELEGATE_TO_GL_1(depthMask, DepthMask, bool)
+
+DELEGATE_TO_GL_2(depthRange, DepthRange, double, double)
+
+DELEGATE_TO_GL_2(detachShader, DetachShader, WebGLId, WebGLId)
+
+DELEGATE_TO_GL_1(disable, Disable, unsigned long)
+
+void WebGraphicsContext3DDefaultImpl::disableVertexAttribArray(unsigned long index)
+{
+ makeContextCurrent();
+ if (index < NumTrackedPointerStates)
+ m_vertexAttribPointerState[index].enabled = false;
+ glDisableVertexAttribArray(index);
+}
+
+DELEGATE_TO_GL_3(drawArrays, DrawArrays, unsigned long, long, long)
+
+void WebGraphicsContext3DDefaultImpl::drawElements(unsigned long mode, unsigned long count, unsigned long type, long offset)
+{
+ makeContextCurrent();
+ glDrawElements(mode, count, type,
+ reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
+}
+
+DELEGATE_TO_GL_1(enable, Enable, unsigned long)
+
+void WebGraphicsContext3DDefaultImpl::enableVertexAttribArray(unsigned long index)
+{
+ makeContextCurrent();
+ if (index < NumTrackedPointerStates)
+ m_vertexAttribPointerState[index].enabled = true;
+ glEnableVertexAttribArray(index);
+}
+
+DELEGATE_TO_GL(finish, Finish)
+
+DELEGATE_TO_GL(flush, Flush)
+
+void WebGraphicsContext3DDefaultImpl::framebufferRenderbuffer(unsigned long target, unsigned long attachment,
+ unsigned long renderbuffertarget, WebGLId buffer)
+{
+ makeContextCurrent();
+ if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+ glFramebufferRenderbufferEXT(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, buffer);
+ glFramebufferRenderbufferEXT(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, buffer);
+ } else
+ glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, buffer);
+}
+
+DELEGATE_TO_GL_5(framebufferTexture2D, FramebufferTexture2DEXT, unsigned long, unsigned long, unsigned long, WebGLId, long)
+
+DELEGATE_TO_GL_1(frontFace, FrontFace, unsigned long)
+
+void WebGraphicsContext3DDefaultImpl::generateMipmap(unsigned long target)
+{
+ makeContextCurrent();
+ if (glGenerateMipmapEXT)
+ glGenerateMipmapEXT(target);
+ // FIXME: provide alternative code path? This will be unpleasant
+ // to implement if glGenerateMipmapEXT is not available -- it will
+ // require a texture readback and re-upload.
+}
+
+bool WebGraphicsContext3DDefaultImpl::getActiveAttrib(WebGLId program, unsigned long index, ActiveInfo& info)
+{
+ makeContextCurrent();
+ if (!program) {
+ synthesizeGLError(GL_INVALID_VALUE);
+ return false;
+ }
+ GLint maxNameLength = -1;
+ glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength);
+ if (maxNameLength < 0)
+ return false;
+ GLchar* name = 0;
+ if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) {
+ synthesizeGLError(GL_OUT_OF_MEMORY);
+ return false;
+ }
+ GLsizei length = 0;
+ GLint size = -1;
+ GLenum type = 0;
+ glGetActiveAttrib(program, index, maxNameLength,
+ &length, &size, &type, name);
+ if (size < 0) {
+ fastFree(name);
+ return false;
+ }
+ info.name = WebString::fromUTF8(name, length);
+ info.type = type;
+ info.size = size;
+ fastFree(name);
+ return true;
+}
+
+bool WebGraphicsContext3DDefaultImpl::getActiveUniform(WebGLId program, unsigned long index, ActiveInfo& info)
+{
+ makeContextCurrent();
+ GLint maxNameLength = -1;
+ glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
+ if (maxNameLength < 0)
+ return false;
+ GLchar* name = 0;
+ if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) {
+ synthesizeGLError(GL_OUT_OF_MEMORY);
+ return false;
+ }
+ GLsizei length = 0;
+ GLint size = -1;
+ GLenum type = 0;
+ glGetActiveUniform(program, index, maxNameLength,
+ &length, &size, &type, name);
+ if (size < 0) {
+ fastFree(name);
+ return false;
+ }
+ info.name = WebString::fromUTF8(name, length);
+ info.type = type;
+ info.size = size;
+ fastFree(name);
+ return true;
+}
+
+DELEGATE_TO_GL_4(getAttachedShaders, GetAttachedShaders, WebGLId, int, int*, unsigned int*)
+
+DELEGATE_TO_GL_2R(getAttribLocation, GetAttribLocation, WebGLId, const char*, int)
+
+DELEGATE_TO_GL_2(getBooleanv, GetBooleanv, unsigned long, unsigned char*)
+
+DELEGATE_TO_GL_3(getBufferParameteriv, GetBufferParameteriv, unsigned long, unsigned long, int*)
+
+WebGraphicsContext3D::Attributes WebGraphicsContext3DDefaultImpl::getContextAttributes()
+{
+ return m_attributes;
+}
+
+unsigned long WebGraphicsContext3DDefaultImpl::getError()
+{
+ if (m_syntheticErrors.size() > 0) {
+ ListHashSet<unsigned long>::iterator iter = m_syntheticErrors.begin();
+ unsigned long err = *iter;
+ m_syntheticErrors.remove(iter);
+ return err;
+ }
+
+ makeContextCurrent();
+ return glGetError();
+}
+
+DELEGATE_TO_GL_2(getFloatv, GetFloatv, unsigned long, float*)
+
+void WebGraphicsContext3DDefaultImpl::getFramebufferAttachmentParameteriv(unsigned long target, unsigned long attachment,
+ unsigned long pname, int* value)
+{
+ makeContextCurrent();
+ if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
+ attachment = GL_DEPTH_ATTACHMENT; // Or GL_STENCIL_ATTACHMENT, either works.
+ glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, value);
+}
+
+void WebGraphicsContext3DDefaultImpl::getIntegerv(unsigned long pname, int* value)
+{
+ // Need to emulate IMPLEMENTATION_COLOR_READ_FORMAT/TYPE for GL. Any valid
+ // combination should work, but GL_RGB/GL_UNSIGNED_BYTE might be the most
+ // useful for desktop WebGL users.
+ // Need to emulate MAX_FRAGMENT/VERTEX_UNIFORM_VECTORS and MAX_VARYING_VECTORS
+ // because desktop GL's corresponding queries return the number of components
+ // whereas GLES2 return the number of vectors (each vector has 4 components).
+ // Therefore, the value returned by desktop GL needs to be divided by 4.
+ makeContextCurrent();
+ switch (pname) {
+ case 0x8B9B: // IMPLEMENTATION_COLOR_READ_FORMAT
+ *value = GL_RGB;
+ break;
+ case 0x8B9A: // IMPLEMENTATION_COLOR_READ_TYPE
+ *value = GL_UNSIGNED_BYTE;
+ break;
+ case 0x8DFD: // MAX_FRAGMENT_UNIFORM_VECTORS
+ glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, value);
+ *value /= 4;
+ break;
+ case 0x8DFB: // MAX_VERTEX_UNIFORM_VECTORS
+ glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, value);
+ *value /= 4;
+ break;
+ case 0x8DFC: // MAX_VARYING_VECTORS
+ glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
+ *value /= 4;
+ break;
+ default:
+ glGetIntegerv(pname, value);
+ }
+}
+
+DELEGATE_TO_GL_3(getProgramiv, GetProgramiv, WebGLId, unsigned long, int*)
+
+WebString WebGraphicsContext3DDefaultImpl::getProgramInfoLog(WebGLId program)
+{
+ makeContextCurrent();
+ GLint logLength;
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+ if (!logLength)
+ return WebString();
+ GLchar* log = 0;
+ if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
+ return WebString();
+ GLsizei returnedLogLength;
+ glGetProgramInfoLog(program, logLength, &returnedLogLength, log);
+ ASSERT(logLength == returnedLogLength + 1);
+ WebString res = WebString::fromUTF8(log, returnedLogLength);
+ fastFree(log);
+ return res;
+}
+
+DELEGATE_TO_GL_3(getRenderbufferParameteriv, GetRenderbufferParameterivEXT, unsigned long, unsigned long, int*)
+
+DELEGATE_TO_GL_3(getShaderiv, GetShaderiv, WebGLId, unsigned long, int*)
+
+WebString WebGraphicsContext3DDefaultImpl::getShaderInfoLog(WebGLId shader)
+{
+ makeContextCurrent();
+ GLint logLength;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
+ if (!logLength)
+ return WebString();
+ GLchar* log = 0;
+ if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
+ return WebString();
+ GLsizei returnedLogLength;
+ glGetShaderInfoLog(shader, logLength, &returnedLogLength, log);
+ ASSERT(logLength == returnedLogLength + 1);
+ WebString res = WebString::fromUTF8(log, returnedLogLength);
+ fastFree(log);
+ return res;
+}
+
+WebString WebGraphicsContext3DDefaultImpl::getShaderSource(WebGLId shader)
+{
+ makeContextCurrent();
+ GLint logLength;
+ glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
+ if (!logLength)
+ return WebString();
+ GLchar* log = 0;
+ if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
+ return WebString();
+ GLsizei returnedLogLength;
+ glGetShaderSource(shader, logLength, &returnedLogLength, log);
+ ASSERT(logLength == returnedLogLength + 1);
+ WebString res = WebString::fromUTF8(log, returnedLogLength);
+ fastFree(log);
+ return res;
+}
+
+WebString WebGraphicsContext3DDefaultImpl::getString(unsigned long name)
+{
+ makeContextCurrent();
+ return WebString::fromUTF8(reinterpret_cast<const char*>(glGetString(name)));
+}
+
+DELEGATE_TO_GL_3(getTexParameterfv, GetTexParameterfv, unsigned long, unsigned long, float*)
+
+DELEGATE_TO_GL_3(getTexParameteriv, GetTexParameteriv, unsigned long, unsigned long, int*)
+
+DELEGATE_TO_GL_3(getUniformfv, GetUniformfv, WebGLId, long, float*)
+
+DELEGATE_TO_GL_3(getUniformiv, GetUniformiv, WebGLId, long, int*)
+
+DELEGATE_TO_GL_2R(getUniformLocation, GetUniformLocation, WebGLId, const char*, long)
+
+DELEGATE_TO_GL_3(getVertexAttribfv, GetVertexAttribfv, unsigned long, unsigned long, float*)
+
+DELEGATE_TO_GL_3(getVertexAttribiv, GetVertexAttribiv, unsigned long, unsigned long, int*)
+
+long WebGraphicsContext3DDefaultImpl::getVertexAttribOffset(unsigned long index, unsigned long pname)
+{
+ // FIXME: implement.
+ notImplemented();
+ return 0;
+}
+
+DELEGATE_TO_GL_2(hint, Hint, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_1R(isBuffer, IsBuffer, WebGLId, bool)
+
+DELEGATE_TO_GL_1R(isEnabled, IsEnabled, unsigned long, bool)
+
+DELEGATE_TO_GL_1R(isFramebuffer, IsFramebuffer, WebGLId, bool)
+
+DELEGATE_TO_GL_1R(isProgram, IsProgram, WebGLId, bool)
+
+DELEGATE_TO_GL_1R(isRenderbuffer, IsRenderbuffer, WebGLId, bool)
+
+DELEGATE_TO_GL_1R(isShader, IsShader, WebGLId, bool)
+
+DELEGATE_TO_GL_1R(isTexture, IsTexture, WebGLId, bool)
+
+DELEGATE_TO_GL_1(lineWidth, LineWidth, double)
+
+DELEGATE_TO_GL_1(linkProgram, LinkProgram, WebGLId)
+
+DELEGATE_TO_GL_2(pixelStorei, PixelStorei, unsigned long, long)
+
+DELEGATE_TO_GL_2(polygonOffset, PolygonOffset, double, double)
+
+void WebGraphicsContext3DDefaultImpl::readPixels(long x, long y, unsigned long width, unsigned long height, unsigned long format, unsigned long type, void* pixels)
+{
+ makeContextCurrent();
+ // FIXME: remove the two glFlush calls when the driver bug is fixed, i.e.,
+ // all previous rendering calls should be done before reading pixels.
+ glFlush();
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
+ glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
+ glFlush();
+ }
+#endif
+ glReadPixels(x, y, width, height, format, type, pixels);
+#ifndef RENDER_TO_DEBUGGING_WINDOW
+ if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
+#endif
+}
+
+void WebGraphicsContext3DDefaultImpl::releaseShaderCompiler()
+{
+}
+
+void WebGraphicsContext3DDefaultImpl::renderbufferStorage(unsigned long target,
+ unsigned long internalformat,
+ unsigned long width,
+ unsigned long height)
+{
+ makeContextCurrent();
+ switch (internalformat) {
+ case GL_DEPTH_STENCIL:
+ internalformat = GL_DEPTH24_STENCIL8_EXT;
+ break;
+ case GL_DEPTH_COMPONENT16:
+ internalformat = GL_DEPTH_COMPONENT;
+ break;
+ case GL_RGBA4:
+ case GL_RGB5_A1:
+ internalformat = GL_RGBA;
+ break;
+ case 0x8D62: // GL_RGB565
+ internalformat = GL_RGB;
+ break;
+ }
+ glRenderbufferStorageEXT(target, internalformat, width, height);
+}
+
+DELEGATE_TO_GL_2(sampleCoverage, SampleCoverage, double, bool)
+
+DELEGATE_TO_GL_4(scissor, Scissor, long, long, unsigned long, unsigned long)
+
+void WebGraphicsContext3DDefaultImpl::shaderSource(WebGLId shader, const char* string)
+{
+ makeContextCurrent();
+ GLint length = strlen(string);
+ glShaderSource(shader, 1, &string, &length);
+}
+
+DELEGATE_TO_GL_3(stencilFunc, StencilFunc, unsigned long, long, unsigned long)
+
+DELEGATE_TO_GL_4(stencilFuncSeparate, StencilFuncSeparate, unsigned long, unsigned long, long, unsigned long)
+
+DELEGATE_TO_GL_1(stencilMask, StencilMask, unsigned long)
+
+DELEGATE_TO_GL_2(stencilMaskSeparate, StencilMaskSeparate, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_3(stencilOp, StencilOp, unsigned long, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_4(stencilOpSeparate, StencilOpSeparate, unsigned long, unsigned long, unsigned long, unsigned long)
+
+DELEGATE_TO_GL_9(texImage2D, TexImage2D, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, const void*)
+
+DELEGATE_TO_GL_3(texParameterf, TexParameterf, unsigned, unsigned, float);
+
+DELEGATE_TO_GL_3(texParameteri, TexParameteri, unsigned, unsigned, int);
+
+DELEGATE_TO_GL_9(texSubImage2D, TexSubImage2D, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, const void*)
+
+DELEGATE_TO_GL_2(uniform1f, Uniform1f, long, float)
+
+DELEGATE_TO_GL_3(uniform1fv, Uniform1fv, long, int, float*)
+
+DELEGATE_TO_GL_2(uniform1i, Uniform1i, long, int)
+
+DELEGATE_TO_GL_3(uniform1iv, Uniform1iv, long, int, int*)
+
+DELEGATE_TO_GL_3(uniform2f, Uniform2f, long, float, float)
+
+DELEGATE_TO_GL_3(uniform2fv, Uniform2fv, long, int, float*)
+
+DELEGATE_TO_GL_3(uniform2i, Uniform2i, long, int, int)
+
+DELEGATE_TO_GL_3(uniform2iv, Uniform2iv, long, int, int*)
+
+DELEGATE_TO_GL_4(uniform3f, Uniform3f, long, float, float, float)
+
+DELEGATE_TO_GL_3(uniform3fv, Uniform3fv, long, int, float*)
+
+DELEGATE_TO_GL_4(uniform3i, Uniform3i, long, int, int, int)
+
+DELEGATE_TO_GL_3(uniform3iv, Uniform3iv, long, int, int*)
+
+DELEGATE_TO_GL_5(uniform4f, Uniform4f, long, float, float, float, float)
+
+DELEGATE_TO_GL_3(uniform4fv, Uniform4fv, long, int, float*)
+
+DELEGATE_TO_GL_5(uniform4i, Uniform4i, long, int, int, int, int)
+
+DELEGATE_TO_GL_3(uniform4iv, Uniform4iv, long, int, int*)
+
+DELEGATE_TO_GL_4(uniformMatrix2fv, UniformMatrix2fv, long, int, bool, const float*)
+
+DELEGATE_TO_GL_4(uniformMatrix3fv, UniformMatrix3fv, long, int, bool, const float*)
+
+DELEGATE_TO_GL_4(uniformMatrix4fv, UniformMatrix4fv, long, int, bool, const float*)
+
+DELEGATE_TO_GL_1(useProgram, UseProgram, WebGLId)
+
+DELEGATE_TO_GL_1(validateProgram, ValidateProgram, WebGLId)
+
+DELEGATE_TO_GL_2(vertexAttrib1f, VertexAttrib1f, unsigned long, float)
+
+DELEGATE_TO_GL_2(vertexAttrib1fv, VertexAttrib1fv, unsigned long, const float*)
+
+DELEGATE_TO_GL_3(vertexAttrib2f, VertexAttrib2f, unsigned long, float, float)
+
+DELEGATE_TO_GL_2(vertexAttrib2fv, VertexAttrib2fv, unsigned long, const float*)
+
+DELEGATE_TO_GL_4(vertexAttrib3f, VertexAttrib3f, unsigned long, float, float, float)
+
+DELEGATE_TO_GL_2(vertexAttrib3fv, VertexAttrib3fv, unsigned long, const float*)
+
+DELEGATE_TO_GL_5(vertexAttrib4f, VertexAttrib4f, unsigned long, float, float, float, float)
+
+DELEGATE_TO_GL_2(vertexAttrib4fv, VertexAttrib4fv, unsigned long, const float*)
+
+void WebGraphicsContext3DDefaultImpl::vertexAttribPointer(unsigned long indx, int size, int type, bool normalized,
+ unsigned long stride, unsigned long offset)
+{
+ makeContextCurrent();
+
+ if (m_boundArrayBuffer <= 0) {
+ // FIXME: raise exception.
+ // LogMessagef(("bufferData: no buffer bound"));
+ return;
+ }
+
+ if (indx < NumTrackedPointerStates) {
+ VertexAttribPointerState& state = m_vertexAttribPointerState[indx];
+ state.buffer = m_boundArrayBuffer;
+ state.indx = indx;
+ state.size = size;
+ state.type = type;
+ state.normalized = normalized;
+ state.stride = stride;
+ state.offset = offset;
+ }
+
+ glVertexAttribPointer(indx, size, type, normalized, stride,
+ reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
+}
+
+DELEGATE_TO_GL_4(viewport, Viewport, long, long, unsigned long, unsigned long)
+
+unsigned WebGraphicsContext3DDefaultImpl::createBuffer()
+{
+ makeContextCurrent();
+ GLuint o;
+ glGenBuffers(1, &o);
+ return o;
+}
+
+unsigned WebGraphicsContext3DDefaultImpl::createFramebuffer()
+{
+ makeContextCurrent();
+ GLuint o = 0;
+ glGenFramebuffersEXT(1, &o);
+ return o;
+}
+
+unsigned WebGraphicsContext3DDefaultImpl::createProgram()
+{
+ makeContextCurrent();
+ return glCreateProgram();
+}
+
+unsigned WebGraphicsContext3DDefaultImpl::createRenderbuffer()
+{
+ makeContextCurrent();
+ GLuint o;
+ glGenRenderbuffersEXT(1, &o);
+ return o;
+}
+
+DELEGATE_TO_GL_1R(createShader, CreateShader, unsigned long, unsigned);
+
+unsigned WebGraphicsContext3DDefaultImpl::createTexture()
+{
+ makeContextCurrent();
+ GLuint o;
+ glGenTextures(1, &o);
+ return o;
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteBuffer(unsigned buffer)
+{
+ makeContextCurrent();
+ glDeleteBuffers(1, &buffer);
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteFramebuffer(unsigned framebuffer)
+{
+ makeContextCurrent();
+ glDeleteFramebuffersEXT(1, &framebuffer);
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteProgram(unsigned program)
+{
+ makeContextCurrent();
+ glDeleteProgram(program);
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteRenderbuffer(unsigned renderbuffer)
+{
+ makeContextCurrent();
+ glDeleteRenderbuffersEXT(1, &renderbuffer);
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteShader(unsigned shader)
+{
+ makeContextCurrent();
+ glDeleteShader(shader);
+}
+
+void WebGraphicsContext3DDefaultImpl::deleteTexture(unsigned texture)
+{
+ makeContextCurrent();
+ glDeleteTextures(1, &texture);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(3D_CANVAS)