GraphicsContextGLOpenGLBase.cpp [plain text]
#include "config.h"
#include "GraphicsContextGLOpenGL.h"
#if ENABLE(GRAPHICS_CONTEXT_GL) && USE(OPENGL)
#include "ExtensionsGLOpenGL.h"
#include "IntRect.h"
#include "IntSize.h"
#include "Logging.h"
#include "NotImplemented.h"
#include "TemporaryOpenGLSetting.h"
#include <algorithm>
#include <cstring>
#include <wtf/MainThread.h>
#include <wtf/text/CString.h>
#if USE(ACCELERATE)
#include <Accelerate/Accelerate.h>
#endif
#if PLATFORM(GTK) || PLATFORM(WIN)
#include "OpenGLShims.h"
#elif USE(OPENGL_ES)
#import <OpenGLES/ES2/glext.h>
#define GL_RGBA32F_ARB 0x8814
#define GL_RGB32F_ARB 0x8815
#elif USE(OPENGL)
#define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
#include <OpenGL/gl.h>
#include <OpenGL/gl3.h>
#undef GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
#endif
namespace WebCore {
void GraphicsContextGLOpenGL::readPixelsAndConvertToBGRAIfNecessary(int x, int y, int width, int height, unsigned char* pixels)
{
auto attrs = contextAttributes();
if (!attrs.alpha && getExtensions().isNVIDIA()) {
::glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
#if USE(ACCELERATE)
vImage_Buffer src;
src.height = height;
src.width = width;
src.rowBytes = width * 4;
src.data = pixels;
vImage_Buffer dest;
dest.height = height;
dest.width = width;
dest.rowBytes = width * 4;
dest.data = pixels;
const uint8_t map[4] = { 2, 1, 0, 3 };
vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags);
#else
int totalBytes = width * height * 4;
for (int i = 0; i < totalBytes; i += 4)
std::swap(pixels[i], pixels[i + 2]);
#endif
} else
::glReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
}
void GraphicsContextGLOpenGL::validateAttributes()
{
validateDepthStencil("GL_EXT_packed_depth_stencil");
}
bool GraphicsContextGLOpenGL::reshapeFBOs(const IntSize& size)
{
auto attrs = contextAttributes();
const int width = size.width();
const int height = size.height();
GLuint colorFormat, internalDepthStencilFormat = 0;
if (attrs.alpha) {
m_internalColorFormat = GL_RGBA8;
colorFormat = GL_RGBA;
} else {
m_internalColorFormat = GL_RGB8;
colorFormat = GL_RGB;
}
if (attrs.stencil || attrs.depth) {
ExtensionsGL& extensions = getExtensions();
if (extensions.supports("GL_EXT_packed_depth_stencil"))
internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
else
internalDepthStencilFormat = GL_DEPTH_COMPONENT;
}
if (attrs.antialias) {
GLint maxSampleCount;
::glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount);
GLint sampleCount = std::min(4, maxSampleCount);
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, m_internalColorFormat, width, height);
::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
if (attrs.stencil || attrs.depth) {
::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height);
if (attrs.stencil)
::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
if (attrs.depth)
::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
}
::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) {
notImplemented();
}
}
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
ASSERT(m_texture);
#if PLATFORM(COCOA)
#if USE(OPENGL_ES)
::glBindRenderbuffer(GL_RENDERBUFFER, m_texture);
::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_texture);
setRenderbufferStorageFromDrawable(m_currentWidth, m_currentHeight);
#else
if (!allocateIOSurfaceBackingStore(size)) {
RELEASE_LOG(WebGL, "Fatal: Unable to allocate backing store of size %d x %d", width, height);
forceContextLost();
return true;
}
::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, m_texture, 0);
#endif // !USE(OPENGL_ES))
#else
::glBindTexture(GL_TEXTURE_2D, m_texture);
::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 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
#endif
attachDepthAndStencilBufferIfNeeded(internalDepthStencilFormat, width, height);
bool mustRestoreFBO = true;
ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO);
if (attrs.antialias) {
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
if (m_state.boundDrawFBO == m_multisampleFBO)
mustRestoreFBO = false;
} else {
if (m_state.boundDrawFBO == m_fbo)
mustRestoreFBO = false;
}
return mustRestoreFBO;
}
void GraphicsContextGLOpenGL::attachDepthAndStencilBufferIfNeeded(GLuint internalDepthStencilFormat, int width, int height)
{
auto attrs = contextAttributes();
if (!attrs.antialias && (attrs.stencil || attrs.depth)) {
::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
::glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
if (attrs.stencil)
::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
if (attrs.depth)
::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) {
notImplemented();
}
}
void GraphicsContextGLOpenGL::resolveMultisamplingIfNecessary(const IntRect& rect)
{
TemporaryOpenGLSetting scopedScissor(GL_SCISSOR_TEST, GL_FALSE);
TemporaryOpenGLSetting scopedDither(GL_DITHER, GL_FALSE);
TemporaryOpenGLSetting scopedDepth(GL_DEPTH_TEST, GL_FALSE);
TemporaryOpenGLSetting scopedStencil(GL_STENCIL_TEST, GL_FALSE);
::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
IntRect resolveRect = rect;
if (rect.isEmpty())
resolveRect = IntRect(0, 0, m_currentWidth, m_currentHeight);
::glBlitFramebufferEXT(resolveRect.x(), resolveRect.y(), resolveRect.maxX(), resolveRect.maxY(), resolveRect.x(), resolveRect.y(), resolveRect.maxX(), resolveRect.maxY(), GL_COLOR_BUFFER_BIT, GL_LINEAR);
}
void GraphicsContextGLOpenGL::renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height)
{
makeContextCurrent();
#if USE(OPENGL)
switch (internalformat) {
case DEPTH_STENCIL:
internalformat = GL_DEPTH24_STENCIL8_EXT;
break;
case DEPTH_COMPONENT16:
internalformat = GL_DEPTH_COMPONENT;
break;
case RGBA4:
case RGB5_A1:
internalformat = GL_RGBA;
break;
case RGB565:
internalformat = GL_RGB;
break;
}
#endif
::glRenderbufferStorageEXT(target, internalformat, width, height);
}
void GraphicsContextGLOpenGL::getIntegerv(GCGLenum pname, GCGLint* value)
{
makeContextCurrent();
switch (pname) {
#if USE(OPENGL)
case MAX_FRAGMENT_UNIFORM_VECTORS:
::glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case MAX_VERTEX_UNIFORM_VECTORS:
::glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case MAX_VARYING_VECTORS:
if (isGLES2Compliant()) {
ASSERT(::glGetError() == GL_NO_ERROR);
::glGetIntegerv(GL_MAX_VARYING_VECTORS, value);
if (::glGetError() == GL_INVALID_ENUM) {
::glGetIntegerv(GL_MAX_VARYING_COMPONENTS, value);
*value /= 4;
}
} else {
::glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
*value /= 4;
}
break;
#endif
case MAX_TEXTURE_SIZE:
::glGetIntegerv(MAX_TEXTURE_SIZE, value);
if (getExtensions().requiresRestrictedMaximumTextureSize())
*value = std::min(4096, *value);
break;
case MAX_CUBE_MAP_TEXTURE_SIZE:
::glGetIntegerv(MAX_CUBE_MAP_TEXTURE_SIZE, value);
if (getExtensions().requiresRestrictedMaximumTextureSize())
*value = std::min(1024, *value);
break;
default:
::glGetIntegerv(pname, value);
}
}
void GraphicsContextGLOpenGL::getShaderPrecisionFormat(GCGLenum shaderType, GCGLenum precisionType, GCGLint* range, GCGLint* precision)
{
UNUSED_PARAM(shaderType);
ASSERT(range);
ASSERT(precision);
makeContextCurrent();
switch (precisionType) {
case GraphicsContextGL::LOW_INT:
case GraphicsContextGL::MEDIUM_INT:
case GraphicsContextGL::HIGH_INT:
range[0] = 31;
range[1] = 30;
precision[0] = 0;
break;
case GraphicsContextGL::LOW_FLOAT:
case GraphicsContextGL::MEDIUM_FLOAT:
case GraphicsContextGL::HIGH_FLOAT:
range[0] = 127;
range[1] = 127;
precision[0] = 23;
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
bool GraphicsContextGLOpenGL::texImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, const void* pixels)
{
if (width && height && !pixels) {
synthesizeGLError(INVALID_VALUE);
return false;
}
GCGLenum openGLFormat = format;
GCGLenum openGLInternalFormat = internalformat;
#if USE(OPENGL)
if (type == GL_FLOAT) {
if (format == GL_RGBA)
openGLInternalFormat = GL_RGBA32F_ARB;
else if (format == GL_RGB)
openGLInternalFormat = GL_RGB32F_ARB;
} else if (type == HALF_FLOAT_OES) {
if (format == GL_RGBA)
openGLInternalFormat = GL_RGBA16F_ARB;
else if (format == GL_RGB)
openGLInternalFormat = GL_RGB16F_ARB;
else if (format == GL_LUMINANCE)
openGLInternalFormat = GL_LUMINANCE16F_ARB;
else if (format == GL_ALPHA)
openGLInternalFormat = GL_ALPHA16F_ARB;
else if (format == GL_LUMINANCE_ALPHA)
openGLInternalFormat = GL_LUMINANCE_ALPHA16F_ARB;
type = GL_HALF_FLOAT_ARB;
}
ASSERT(format != ExtensionsGL::SRGB8_ALPHA8_EXT);
if (format == ExtensionsGL::SRGB_ALPHA_EXT)
openGLFormat = GL_RGBA;
else if (format == ExtensionsGL::SRGB_EXT)
openGLFormat = GL_RGB;
#endif
if (m_usingCoreProfile) {
switch (openGLInternalFormat) {
case ALPHA:
openGLInternalFormat = openGLFormat = RED;
texParameteri(target, TEXTURE_SWIZZLE_A, RED);
break;
case LUMINANCE_ALPHA:
openGLInternalFormat = openGLFormat = RG;
texParameteri(target, TEXTURE_SWIZZLE_R, RED);
texParameteri(target, TEXTURE_SWIZZLE_G, RED);
texParameteri(target, TEXTURE_SWIZZLE_B, RED);
texParameteri(target, TEXTURE_SWIZZLE_A, GREEN);
break;
default:
break;
}
}
texImage2DDirect(target, level, openGLInternalFormat, width, height, border, openGLFormat, type, pixels);
return true;
}
void GraphicsContextGLOpenGL::depthRange(GCGLclampf zNear, GCGLclampf zFar)
{
makeContextCurrent();
::glDepthRange(zNear, zFar);
}
void GraphicsContextGLOpenGL::clearDepth(GCGLclampf depth)
{
makeContextCurrent();
::glClearDepth(depth);
}
#if !PLATFORM(GTK)
ExtensionsGL& GraphicsContextGLOpenGL::getExtensions()
{
if (!m_extensions)
m_extensions = makeUnique<ExtensionsGLOpenGL>(this, isGLES2Compliant());
return *m_extensions;
}
#endif
void GraphicsContextGLOpenGL::readPixels(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, void* data)
{
auto attrs = contextAttributes();
makeContextCurrent();
::glFlush();
ASSERT(m_state.boundReadFBO == m_state.boundDrawFBO);
if (attrs.antialias && m_state.boundDrawFBO == m_multisampleFBO) {
resolveMultisamplingIfNecessary(IntRect(x, y, width, height));
::glBindFramebufferEXT(GraphicsContextGL::FRAMEBUFFER, m_fbo);
::glFlush();
}
::glReadPixels(x, y, width, height, format, type, data);
if (attrs.antialias && m_state.boundDrawFBO == m_multisampleFBO)
::glBindFramebufferEXT(GraphicsContextGL::FRAMEBUFFER, m_multisampleFBO);
}
}
#endif // ENABLE(GRAPHICS_CONTEXT_GL) && USE(OPENGL)