ExtensionsGLOpenGLES.cpp [plain text]
#include "config.h"
#if USE(OPENGL_ES)
#include "ExtensionsGLOpenGLES.h"
#if ENABLE(WEBGL)
#include "GraphicsContextGLOpenGL.h"
#include "NotImplemented.h"
#if USE(LIBEPOXY)
#include "EpoxyEGL.h"
#else
#include <EGL/egl.h>
#endif
namespace WebCore {
ExtensionsGLOpenGLES::ExtensionsGLOpenGLES(GraphicsContextGLOpenGL* context, bool useIndexedGetString)
: ExtensionsGLOpenGLCommon(context, useIndexedGetString)
, m_contextResetStatus(GL_NO_ERROR)
, m_supportsOESvertexArrayObject(false)
, m_supportsIMGMultisampledRenderToTexture(false)
, m_supportsANGLEinstancedArrays(false)
, m_glFramebufferTexture2DMultisampleIMG(0)
, m_glRenderbufferStorageMultisampleIMG(0)
, m_glBindVertexArrayOES(0)
, m_glDeleteVertexArraysOES(0)
, m_glGenVertexArraysOES(0)
, m_glIsVertexArrayOES(0)
, m_glGetGraphicsResetStatusEXT(0)
, m_glReadnPixelsEXT(0)
, m_glGetnUniformfvEXT(0)
, m_glGetnUniformivEXT(0)
, m_glVertexAttribDivisorANGLE(nullptr)
, m_glDrawArraysInstancedANGLE(nullptr)
, m_glDrawElementsInstancedANGLE(nullptr)
{
}
ExtensionsGLOpenGLES::~ExtensionsGLOpenGLES() = default;
bool ExtensionsGLOpenGLES::isEnabled(const String& name)
{
bool enabled = ExtensionsGLOpenGLCommon::isEnabled(name);
if (!enabled)
return false;
if (name == "GL_EXT_robustness")
return m_context->getInteger(ExtensionsGL::CONTEXT_ROBUST_ACCESS) == GL_TRUE;
return true;
}
void ExtensionsGLOpenGLES::framebufferTexture2DMultisampleIMG(unsigned long target, unsigned long attachment, unsigned long textarget, unsigned texture, int level, unsigned long samples)
{
if (!m_context->makeContextCurrent())
return;
if (m_glFramebufferTexture2DMultisampleIMG)
m_glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
else
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::renderbufferStorageMultisampleIMG(unsigned long target, unsigned long samples, unsigned long internalformat, unsigned long width, unsigned long height)
{
if (!m_context->makeContextCurrent())
return;
if (m_glRenderbufferStorageMultisampleIMG)
m_glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
else
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::blitFramebufferANGLE(GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLbitfield, GCGLenum)
{
notImplemented();
}
void ExtensionsGLOpenGLES::renderbufferStorageMultisampleANGLE(GCGLenum target, GCGLsizei samples, GCGLenum internalformat, GCGLsizei width, GCGLsizei height)
{
if (!m_context->makeContextCurrent())
return;
if (m_glRenderbufferStorageMultisampleIMG)
renderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
else
notImplemented();
}
void ExtensionsGLOpenGLES::insertEventMarkerEXT(const String&)
{
notImplemented();
}
void ExtensionsGLOpenGLES::pushGroupMarkerEXT(const String&)
{
notImplemented();
}
void ExtensionsGLOpenGLES::popGroupMarkerEXT(void)
{
notImplemented();
}
PlatformGLObject ExtensionsGLOpenGLES::createVertexArrayOES()
{
if (m_glGenVertexArraysOES) {
if (!m_context->makeContextCurrent())
return 0;
GLuint array = 0;
m_glGenVertexArraysOES(1, &array);
return array;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return 0;
}
void ExtensionsGLOpenGLES::deleteVertexArrayOES(PlatformGLObject array)
{
if (!array)
return;
if (m_glDeleteVertexArraysOES) {
if (!m_context->makeContextCurrent())
return;
m_glDeleteVertexArraysOES(1, &array);
return;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
GCGLboolean ExtensionsGLOpenGLES::isVertexArrayOES(PlatformGLObject array)
{
if (!array)
return GL_FALSE;
if (m_glIsVertexArrayOES) {
if (!m_context->makeContextCurrent())
return GL_FALSE;
return m_glIsVertexArrayOES(array);
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return false;
}
void ExtensionsGLOpenGLES::bindVertexArrayOES(PlatformGLObject array)
{
if (m_glBindVertexArrayOES) {
if (!m_context->makeContextCurrent())
return;
m_glBindVertexArrayOES(array);
} else
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::drawBuffersEXT(GCGLSpan<const GCGLenum> )
{
notImplemented();
}
int ExtensionsGLOpenGLES::getGraphicsResetStatusARB()
{
if (m_contextResetStatus != GL_NO_ERROR)
return m_contextResetStatus;
if (m_glGetGraphicsResetStatusEXT) {
int reasonForReset = UNKNOWN_CONTEXT_RESET_ARB;
if (m_context->makeContextCurrent())
reasonForReset = m_glGetGraphicsResetStatusEXT();
if (reasonForReset != GL_NO_ERROR)
m_contextResetStatus = reasonForReset;
return reasonForReset;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return false;
}
void ExtensionsGLOpenGLES::readnPixelsEXT(int x, int y, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, GCGLsizei bufSize, void *data)
{
if (m_glReadnPixelsEXT) {
if (!m_context->makeContextCurrent())
return;
::glFlush();
m_glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
return;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::getnUniformfvEXT(GCGLuint program, int location, GCGLsizei bufSize, float *params)
{
if (m_glGetnUniformfvEXT) {
if (!m_context->makeContextCurrent())
return;
m_glGetnUniformfvEXT(program, location, bufSize, params);
return;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::getnUniformivEXT(GCGLuint program, int location, GCGLsizei bufSize, int *params)
{
if (m_glGetnUniformivEXT) {
if (!m_context->makeContextCurrent())
return;
m_glGetnUniformivEXT(program, location, bufSize, params);
return;
}
m_context->synthesizeGLError(GL_INVALID_OPERATION);
}
void ExtensionsGLOpenGLES::drawArraysInstancedANGLE(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount)
{
if (!m_glDrawArraysInstancedANGLE) {
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return;
}
if (!m_context->makeContextCurrent())
return;
m_glDrawArraysInstancedANGLE(mode, first, count, primcount);
}
void ExtensionsGLOpenGLES::drawElementsInstancedANGLE(GCGLenum mode, GCGLsizei count, GCGLenum type, GCGLvoidptr offset, GCGLsizei primcount)
{
if (!m_glDrawElementsInstancedANGLE) {
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return;
}
if (!m_context->makeContextCurrent())
return;
m_glDrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)), primcount);
}
void ExtensionsGLOpenGLES::vertexAttribDivisorANGLE(GCGLuint index, GCGLuint divisor)
{
if (!m_glVertexAttribDivisorANGLE) {
m_context->synthesizeGLError(GL_INVALID_OPERATION);
return;
}
if (!m_context->makeContextCurrent())
return;
m_glVertexAttribDivisorANGLE(index, divisor);
}
bool ExtensionsGLOpenGLES::supportsExtension(const String& name)
{
if (m_availableExtensions.contains(name)) {
if (!m_supportsOESvertexArrayObject && name == "GL_OES_vertex_array_object") {
m_glBindVertexArrayOES = reinterpret_cast<PFNGLBINDVERTEXARRAYOESPROC>(eglGetProcAddress("glBindVertexArrayOES"));
m_glGenVertexArraysOES = reinterpret_cast<PFNGLGENVERTEXARRAYSOESPROC>(eglGetProcAddress("glGenVertexArraysOES"));
m_glDeleteVertexArraysOES = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOESPROC>(eglGetProcAddress("glDeleteVertexArraysOES"));
m_glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOESPROC>(eglGetProcAddress("glIsVertexArrayOES"));
m_supportsOESvertexArrayObject = true;
} else if (!m_supportsIMGMultisampledRenderToTexture && name == "GL_IMG_multisampled_render_to_texture") {
m_glFramebufferTexture2DMultisampleIMG = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC>(eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"));
m_glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC>(eglGetProcAddress("glRenderbufferStorageMultisampleIMG"));
m_supportsIMGMultisampledRenderToTexture = true;
} else if (!m_glGetGraphicsResetStatusEXT && name == "GL_EXT_robustness") {
m_glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>(eglGetProcAddress("glGetGraphicsResetStatusEXT"));
m_glReadnPixelsEXT = reinterpret_cast<PFNGLREADNPIXELSEXTPROC>(eglGetProcAddress("glReadnPixelsEXT"));
m_glGetnUniformfvEXT = reinterpret_cast<PFNGLGETNUNIFORMFVEXTPROC>(eglGetProcAddress("glGetnUniformfvEXT"));
m_glGetnUniformivEXT = reinterpret_cast<PFNGLGETNUNIFORMIVEXTPROC>(eglGetProcAddress("glGetnUniformivEXT"));
} else if (!m_supportsANGLEinstancedArrays && name == "GL_ANGLE_instanced_arrays") {
m_glVertexAttribDivisorANGLE = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORANGLEPROC>(eglGetProcAddress("glVertexAttribDivisorANGLE"));
m_glDrawArraysInstancedANGLE = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawArraysInstancedANGLE"));
m_glDrawElementsInstancedANGLE = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawElementsInstancedANGLE"));
m_supportsANGLEinstancedArrays = true;
} else if (name == "GL_EXT_draw_buffers") {
return false;
}
return true;
}
return false;
}
String ExtensionsGLOpenGLES::getExtensions()
{
return String(reinterpret_cast<const char*>(::glGetString(GL_EXTENSIONS)));
}
}
#endif // ENABLE(WEBGL)
#endif // USE(OPENGL_ES)