/* * Copyright (C) 2010 Apple Inc. All rights reserved. * Copyright (C) 2011 Google Inc. All rights reserved. * Copyright (C) 2012 ChangSeok Oh * Copyright (C) 2012 Research In Motion Limited. All rights reserved. * * 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(WEBGL) && USE(OPENGL_ES) #include "ByteArrayPixelBuffer.h" #include "ExtensionsGLOpenGLES.h" #include "IntRect.h" #include "IntSize.h" #include "NotImplemented.h" #include namespace WebCore { void GraphicsContextGLOpenGL::readnPixels(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, GCGLSpan data) { if (!makeContextCurrent()) return; auto attributes = contextAttributes(); // 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(); ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO); if (attributes.antialias && m_state.boundDrawFBO == m_multisampleFBO) { resolveMultisamplingIfNecessary(IntRect(x, y, width, height)); ::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo); ::glFlush(); } ::glReadPixels(x, y, width, height, format, type, data.data); if (attributes.antialias && m_state.boundDrawFBO == m_multisampleFBO) ::glBindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); } RefPtr GraphicsContextGLOpenGL::readPixelsForPaintResults() { PixelBufferFormat format { AlphaPremultiplication::Unpremultiplied, PixelFormat::RGBA8, DestinationColorSpace::SRGB() }; auto pixelBuffer = ByteArrayPixelBuffer::tryCreate(format, getInternalFramebufferSize()); if (!pixelBuffer) return nullptr; GLint packAlignment = 4; bool mustRestorePackAlignment = false; ::glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment); if (packAlignment > 4) { ::glPixelStorei(GL_PACK_ALIGNMENT, 4); mustRestorePackAlignment = true; } ::glReadPixels(0, 0, pixelBuffer->size().width(), pixelBuffer->size().height(), GL_RGBA, GL_UNSIGNED_BYTE, pixelBuffer->bytes()); if (mustRestorePackAlignment) ::glPixelStorei(GL_PACK_ALIGNMENT, packAlignment); return pixelBuffer; } bool GraphicsContextGLOpenGL::reshapeFBOs(const IntSize& size) { const int width = size.width(); const int height = size.height(); GLuint colorFormat = 0; auto attributes = contextAttributes(); if (attributes.alpha) { m_internalColorFormat = GL_RGBA; colorFormat = GL_RGBA; } else { m_internalColorFormat = GL_RGB; colorFormat = GL_RGB; } // We don't allow the logic where stencil is required and depth is not. // See GraphicsContextGLOpenGL::validateAttributes. bool supportPackedDepthStencilBuffer = (attributes.stencil || attributes.depth) && supportsExtension("GL_OES_packed_depth_stencil"_s); // Resize regular FBO. bool mustRestoreFBO = false; ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO); if (m_state.boundDrawFBO != m_fbo) { mustRestoreFBO = true; ::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo); } ASSERT(m_texture); ::glBindTexture(GL_TEXTURE_2D, m_texture); ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0); ::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0); #if USE(COORDINATED_GRAPHICS) if (m_compositorTexture) { ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture); ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0); ::glBindTexture(GL_TEXTURE_2D, 0); } ::glBindTexture(GL_TEXTURE_2D, m_intermediateTexture); ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0); ::glBindTexture(GL_TEXTURE_2D, 0); #endif ExtensionsGLOpenGLES& extensions = getExtensions(); if (extensions.isImagination() && attributes.antialias) { GLint maxSampleCount; ::glGetIntegerv(ExtensionsGLOpenGLES::MAX_SAMPLES_IMG, &maxSampleCount); GLint sampleCount = std::min(8, maxSampleCount); extensions.framebufferTexture2DMultisampleIMG(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0, sampleCount); if (attributes.stencil || attributes.depth) { // Use a 24 bit depth buffer where we know we have it. if (supportPackedDepthStencilBuffer) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer); extensions.renderbufferStorageMultisampleANGLE(GL_RENDERBUFFER, sampleCount, GL_DEPTH24_STENCIL8_OES, width, height); if (attributes.stencil) ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); if (attributes.depth) ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); } else { if (attributes.stencil) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBuffer); extensions.renderbufferStorageMultisampleANGLE(GL_RENDERBUFFER, sampleCount, GL_STENCIL_INDEX8, width, height); ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer); } if (attributes.depth) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthBuffer); extensions.renderbufferStorageMultisampleANGLE(GL_RENDERBUFFER, sampleCount, GL_DEPTH_COMPONENT16, width, height); ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthBuffer); } } ::glBindRenderbuffer(GL_RENDERBUFFER, 0); } } else { if (attributes.stencil || attributes.depth) { // Use a 24 bit depth buffer where we know we have it. if (supportPackedDepthStencilBuffer) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer); ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, width, height); if (attributes.stencil) ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); if (attributes.depth) ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); } else { if (attributes.stencil) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBuffer); ::glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height); ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer); } if (attributes.depth) { ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthBuffer); ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height); ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthBuffer); } } ::glBindRenderbuffer(GL_RENDERBUFFER, 0); } } if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { // FIXME: cleanup notImplemented(); } return mustRestoreFBO; } void GraphicsContextGLOpenGL::resolveMultisamplingIfNecessary(const IntRect&) { // FIXME: We don't support antialiasing yet. notImplemented(); } void GraphicsContextGLOpenGL::renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height) { if (!makeContextCurrent()) return; ::glRenderbufferStorage(target, internalformat, width, height); } void GraphicsContextGLOpenGL::getIntegerv(GCGLenum pname, GCGLSpan value) { if (!makeContextCurrent()) return; ::glGetIntegerv(pname, value.data); } void GraphicsContextGLOpenGL::getShaderPrecisionFormat(GCGLenum shaderType, GCGLenum precisionType, GCGLSpan range, GCGLint* precision) { ASSERT(range.data); ASSERT(precision); if (!makeContextCurrent()) return; ::glGetShaderPrecisionFormat(shaderType, precisionType, range.data, precision); } void GraphicsContextGLOpenGL::texImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, GCGLSpan pixels) { if (width && height && !pixels.data) { synthesizeGLError(INVALID_VALUE); return; } texImage2DDirect(target, level, internalformat, width, height, border, format, type, pixels.data); } void GraphicsContextGLOpenGL::validateAttributes() { validateDepthStencil("GL_OES_packed_depth_stencil"_s); auto attributes = contextAttributes(); if (attributes.antialias && !supportsExtension("GL_IMG_multisampled_render_to_texture"_s)) { attributes.antialias = false; setContextAttributes(attributes); } } void GraphicsContextGLOpenGL::depthRange(GCGLclampf zNear, GCGLclampf zFar) { if (!makeContextCurrent()) return; ::glDepthRangef(zNear, zFar); } void GraphicsContextGLOpenGL::clearDepth(GCGLclampf depth) { if (!makeContextCurrent()) return; ::glClearDepthf(depth); } #if !PLATFORM(GTK) ExtensionsGLOpenGLES& GraphicsContextGLOpenGL::getExtensions() { if (!m_extensions) m_extensions = makeUnique(this, isGLES2Compliant()); return *m_extensions; } #endif } #endif // ENABLE(WEBGL) && USE(OPENGL_ES)