| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Data Visualization module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 or (at your option) any later version |
| ** approved by the KDE Free Qt Foundation. The licenses are as published by |
| ** the Free Software Foundation and appearing in the file LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "glstatestore_p.h" |
| #include <QDebug> |
| #include <QColor> |
| #include <QFile> |
| |
| #ifdef VERBOSE_STATE_STORE |
| static QFile *beforeFile = 0; |
| static QFile *afterFile = 0; |
| #endif |
| |
| GLStateStore::GLStateStore(QOpenGLContext *context, QObject *parent) : |
| QObject(parent), |
| QOpenGLFunctions(context) |
| #ifdef VERBOSE_STATE_STORE |
| , m_map(EnumToStringMap::newInstance()) |
| #endif |
| { |
| GLint maxVertexAttribs; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); |
| |
| #ifdef VERBOSE_STATE_STORE |
| qDebug() << "GL_MAX_VERTEX_ATTRIBS: " << maxVertexAttribs; |
| if (!beforeFile) { |
| beforeFile = new QFile(QStringLiteral("state_before.txt")); |
| afterFile = new QFile(QStringLiteral("state_after.txt")); |
| beforeFile->open(QIODevice::WriteOnly); |
| afterFile->open(QIODevice::WriteOnly); |
| QDebug beforeInit(beforeFile); |
| QDebug afterInit(afterFile); |
| beforeInit << "GL states before 'context switch'" << endl; |
| afterInit << "GL states after 'context switch'" << endl; |
| } |
| #endif |
| |
| m_maxVertexAttribs = qMin(maxVertexAttribs, 2); // Datavis only uses 2 attribs max |
| m_vertexAttribArrayEnabledStates.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArrayBoundBuffers.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArraySizes.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArrayTypes.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArrayNormalized.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArrayStrides.reset(new GLint[maxVertexAttribs]); |
| m_vertexAttribArrayOffsets.reset(new void *[maxVertexAttribs]); |
| |
| initGLDefaultState(); |
| } |
| |
| GLStateStore::~GLStateStore() |
| { |
| #ifdef VERBOSE_STATE_STORE |
| EnumToStringMap::deleteInstance(); |
| m_map = 0; |
| #endif |
| } |
| |
| void GLStateStore::storeGLState() |
| { |
| #ifdef VERBOSE_STATE_STORE |
| printCurrentState(true); |
| #endif |
| |
| #if !defined(QT_OPENGL_ES_2) |
| glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &m_drawFramebuffer); |
| glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &m_readFramebuffer); |
| glGetIntegerv(GL_RENDERBUFFER_BINDING, &m_renderbuffer); |
| #endif |
| glGetFloatv(GL_COLOR_CLEAR_VALUE, m_clearColor); |
| m_isBlendingEnabled = glIsEnabled(GL_BLEND); |
| m_isDepthTestEnabled = glIsEnabled(GL_DEPTH_TEST); |
| glGetBooleanv(GL_DEPTH_WRITEMASK, &m_isDepthWriteEnabled); |
| glGetFloatv(GL_DEPTH_CLEAR_VALUE, &m_clearDepth); |
| glGetIntegerv(GL_DEPTH_FUNC, &m_depthFunc); |
| glGetBooleanv(GL_POLYGON_OFFSET_FILL, &m_polygonOffsetFillEnabled); |
| glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &m_polygonOffsetFactor); |
| glGetFloatv(GL_POLYGON_OFFSET_UNITS, &m_polygonOffsetUnits); |
| |
| glGetIntegerv(GL_CURRENT_PROGRAM, &m_currentProgram); |
| glGetIntegerv(GL_ACTIVE_TEXTURE, &m_activeTexture); |
| glGetIntegerv(GL_TEXTURE_BINDING_2D, &m_texBinding2D); |
| glGetIntegerv(GL_FRONT_FACE, &m_frontFace); |
| m_isCullFaceEnabled = glIsEnabled(GL_CULL_FACE); |
| glGetIntegerv(GL_CULL_FACE_MODE, &m_cullFaceMode); |
| glGetIntegerv(GL_BLEND_EQUATION_RGB, &m_blendEquationRGB); |
| glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &m_blendEquationAlpha); |
| glGetIntegerv(GL_BLEND_DST_ALPHA, &m_blendDestAlpha); |
| glGetIntegerv(GL_BLEND_DST_RGB, &m_blendDestRGB); |
| glGetIntegerv(GL_BLEND_SRC_ALPHA, &m_blendSrcAlpha); |
| glGetIntegerv(GL_BLEND_SRC_RGB, &m_blendSrcRGB); |
| glGetIntegerv(GL_SCISSOR_BOX, m_scissorBox); |
| m_isScissorTestEnabled = glIsEnabled(GL_SCISSOR_TEST); |
| |
| glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &m_boundArrayBuffer); |
| glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &m_boundElementArrayBuffer); |
| |
| for (int i = 0; i < m_maxVertexAttribs;i++) { |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, |
| &m_vertexAttribArrayEnabledStates[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, |
| &m_vertexAttribArrayBoundBuffers[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &m_vertexAttribArraySizes[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &m_vertexAttribArrayTypes[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, |
| &m_vertexAttribArrayNormalized[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &m_vertexAttribArrayStrides[i]); |
| } |
| } |
| |
| #ifdef VERBOSE_STATE_STORE |
| void GLStateStore::printCurrentState(bool in) |
| { |
| QFile *file; |
| if (in) |
| file = beforeFile; |
| else |
| file = afterFile; |
| |
| if (file->isOpen()) { |
| QDebug msg(file); |
| #if !defined(QT_OPENGL_ES_2) |
| GLint drawFramebuffer; |
| GLint readFramebuffer; |
| GLint renderbuffer; |
| #endif |
| GLfloat clearColor[4]; |
| GLfloat clearDepth; |
| GLboolean isBlendingEnabled = glIsEnabled(GL_BLEND); |
| GLboolean isDepthTestEnabled = glIsEnabled(GL_DEPTH_TEST); |
| GLint depthFunc; |
| GLboolean isDepthWriteEnabled; |
| GLint currentProgram; |
| GLint *vertexAttribArrayEnabledStates = new GLint[m_maxVertexAttribs]; |
| GLint *vertexAttribArrayBoundBuffers = new GLint[m_maxVertexAttribs]; |
| GLint *vertexAttribArraySizes = new GLint[m_maxVertexAttribs]; |
| GLint *vertexAttribArrayTypes = new GLint[m_maxVertexAttribs]; |
| GLint *vertexAttribArrayNormalized = new GLint[m_maxVertexAttribs]; |
| GLint *vertexAttribArrayStrides = new GLint[m_maxVertexAttribs]; |
| GLint activeTexture; |
| GLint texBinding2D; |
| GLint arrayBufferBinding; |
| GLint frontFace; |
| GLboolean isCullFaceEnabled = glIsEnabled(GL_CULL_FACE); |
| GLint cullFaceMode; |
| GLint blendEquationRGB; |
| GLint blendEquationAlpha; |
| |
| GLint blendDestAlpha; |
| GLint blendDestRGB; |
| GLint blendSrcAlpha; |
| GLint blendSrcRGB; |
| GLint scissorBox[4]; |
| GLboolean isScissorTestEnabled = glIsEnabled(GL_SCISSOR_TEST); |
| GLint boundElementArrayBuffer; |
| GLboolean polygonOffsetFillEnabled; |
| GLfloat polygonOffsetFactor; |
| GLfloat polygonOffsetUnits; |
| |
| glGetBooleanv(GL_DEPTH_WRITEMASK, &isDepthWriteEnabled); |
| #if !defined(QT_OPENGL_ES_2) |
| glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFramebuffer); |
| glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &readFramebuffer); |
| glGetIntegerv(GL_RENDERBUFFER_BINDING, &renderbuffer); |
| #endif |
| glGetFloatv(GL_COLOR_CLEAR_VALUE, clearColor); |
| glGetFloatv(GL_DEPTH_CLEAR_VALUE, &clearDepth); |
| glGetIntegerv(GL_DEPTH_FUNC, &depthFunc); |
| glGetBooleanv(GL_POLYGON_OFFSET_FILL, &polygonOffsetFillEnabled); |
| glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &polygonOffsetFactor); |
| glGetFloatv(GL_POLYGON_OFFSET_UNITS, &polygonOffsetUnits); |
| |
| glGetIntegerv(GL_CURRENT_PROGRAM, ¤tProgram); |
| glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTexture); |
| glGetIntegerv(GL_TEXTURE_BINDING_2D, &texBinding2D ); |
| glGetIntegerv(GL_FRONT_FACE, &frontFace); |
| glGetIntegerv(GL_CULL_FACE_MODE, &cullFaceMode); |
| glGetIntegerv(GL_BLEND_EQUATION_RGB, &blendEquationRGB); |
| glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &blendEquationAlpha); |
| glGetIntegerv(GL_BLEND_DST_ALPHA, &blendDestAlpha); |
| glGetIntegerv(GL_BLEND_DST_RGB, &blendDestRGB); |
| glGetIntegerv(GL_BLEND_SRC_ALPHA, &blendSrcAlpha); |
| glGetIntegerv(GL_BLEND_SRC_RGB, &blendSrcRGB); |
| glGetIntegerv(GL_SCISSOR_BOX, scissorBox); |
| glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &boundElementArrayBuffer); |
| glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding); |
| |
| for (int i = 0; i < m_maxVertexAttribs;i++) { |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, |
| &vertexAttribArrayEnabledStates[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, |
| &vertexAttribArrayBoundBuffers[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &vertexAttribArraySizes[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &vertexAttribArrayTypes[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, |
| &vertexAttribArrayNormalized[i]); |
| glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &vertexAttribArrayStrides[i]); |
| } |
| |
| QColor color; |
| color.setRgbF(clearColor[0], clearColor[1], clearColor[2]); |
| color.setAlphaF(clearColor[3]); |
| |
| #if !defined(QT_OPENGL_ES_2) |
| msg << "---" << endl; |
| msg << " GL_DRAW_FRAMEBUFFER_BINDING "<< drawFramebuffer << endl; |
| msg << " GL_READ_FRAMEBUFFER_BINDING "<< readFramebuffer << endl; |
| msg << " GL_RENDERBUFFER_BINDING " << renderbuffer << endl; |
| #endif |
| msg << " GL_SCISSOR_TEST " << bool(isScissorTestEnabled) << endl; |
| msg << " GL_SCISSOR_BOX " << m_scissorBox[0] << m_scissorBox[1] << m_scissorBox[2] |
| << m_scissorBox[3] << endl; |
| msg << " GL_COLOR_CLEAR_VALUE "<< color << endl; |
| msg << " GL_DEPTH_CLEAR_VALUE "<< clearDepth << endl; |
| msg << " GL_BLEND "<< bool(isBlendingEnabled) << endl; |
| msg << " GL_BLEND_EQUATION_RGB" << m_map->lookUp(blendEquationRGB) << endl; |
| msg << " GL_BLEND_EQUATION_ALPHA" << m_map->lookUp(blendEquationAlpha) << endl; |
| msg << " GL_BLEND_DST_ALPHA" << m_map->lookUp(blendDestAlpha) << endl; |
| msg << " GL_BLEND_DST_RGB" << m_map->lookUp(blendDestRGB) << endl; |
| msg << " GL_BLEND_SRC_ALPHA" << m_map->lookUp(blendSrcAlpha) << endl; |
| msg << " GL_BLEND_SRC_RGB" << m_map->lookUp(blendSrcRGB) << endl; |
| msg << " GL_DEPTH_TEST "<< bool(isDepthTestEnabled) << endl; |
| msg << " GL_DEPTH_WRITEMASK "<< bool(isDepthWriteEnabled) << endl; |
| msg << " GL_POLYGON_OFFSET_FILL" << bool(polygonOffsetFillEnabled) << endl; |
| msg << " GL_POLYGON_OFFSET_FACTOR "<< polygonOffsetFactor << endl; |
| msg << " GL_POLYGON_OFFSET_UNITS "<< polygonOffsetUnits << endl; |
| msg << " GL_CULL_FACE "<< bool(isCullFaceEnabled) << endl; |
| msg << " GL_CULL_FACE_MODE "<< m_map->lookUp(cullFaceMode) << endl; |
| msg << " GL_DEPTH_FUNC "<< m_map->lookUp(depthFunc) << endl; |
| msg << " GL_FRONT_FACE "<< m_map->lookUp(frontFace) << endl; |
| msg << " GL_CURRENT_PROGRAM "<< currentProgram << endl; |
| msg << " GL_ACTIVE_TEXTURE "<< QString("0x%1").arg(activeTexture, 0, 16) << endl; |
| msg << " GL_TEXTURE_BINDING_2D "<< texBinding2D << endl; |
| msg << " GL_ELEMENT_ARRAY_BUFFER_BINDING "<< boundElementArrayBuffer << endl; |
| msg << " GL_ARRAY_BUFFER_BINDING "<< arrayBufferBinding << endl; |
| for (int i = 0; i < m_maxVertexAttribs;i++) { |
| msg << " GL_VERTEX_ATTRIB_ARRAY_ENABLED "<< i << " = " |
| << bool(vertexAttribArrayEnabledStates[i]) << endl; |
| msg << " GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"<< i << " = " |
| << vertexAttribArrayBoundBuffers[i] << endl; |
| msg << " GL_VERTEX_ATTRIB_ARRAY_SIZE"<< i << " = " |
| << vertexAttribArraySizes[i] << endl; |
| msg << " GL_VERTEX_ATTRIB_ARRAY_TYPE"<< i << " = " |
| << vertexAttribArrayTypes[i] << endl; |
| msg << " GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"<< i << " = " |
| << vertexAttribArrayNormalized[i] << endl; |
| msg << " GL_VERTEX_ATTRIB_ARRAY_STRIDE"<< i << " = " |
| << vertexAttribArrayStrides[i] << endl; |
| } |
| } |
| } |
| #endif |
| |
| void GLStateStore::restoreGLState() |
| { |
| #if !defined(QT_OPENGL_ES_2) |
| glBindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebuffer); |
| glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebuffer); |
| glBindRenderbuffer(GL_RENDERBUFFER_BINDING, m_renderbuffer); |
| #endif |
| |
| if (m_isScissorTestEnabled) |
| glEnable(GL_SCISSOR_TEST); |
| else |
| glDisable(GL_SCISSOR_TEST); |
| |
| glScissor(m_scissorBox[0], m_scissorBox[1], m_scissorBox[2], m_scissorBox[3]); |
| glClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2], m_clearColor[3]); |
| glClearDepthf(m_clearDepth); |
| if (m_isBlendingEnabled) |
| glEnable(GL_BLEND); |
| else |
| glDisable(GL_BLEND); |
| |
| if (m_isDepthTestEnabled) |
| glEnable(GL_DEPTH_TEST); |
| else |
| glDisable(GL_DEPTH_TEST); |
| |
| if (m_isCullFaceEnabled) |
| glEnable(GL_CULL_FACE); |
| else |
| glDisable(GL_CULL_FACE); |
| |
| glCullFace(m_cullFaceMode); |
| |
| glBlendEquationSeparate(m_blendEquationRGB, m_blendEquationAlpha); |
| glBlendFuncSeparate(m_blendSrcRGB, m_blendDestRGB, m_blendSrcAlpha, m_blendDestAlpha); |
| |
| glDepthMask(m_isDepthWriteEnabled); |
| glDepthFunc(m_depthFunc); |
| glFrontFace(m_frontFace); |
| |
| if (m_polygonOffsetFillEnabled) |
| glEnable(GL_POLYGON_OFFSET_FILL); |
| else |
| glDisable(GL_POLYGON_OFFSET_FILL); |
| |
| glPolygonOffset(m_polygonOffsetFactor, m_polygonOffsetUnits); |
| |
| glUseProgram(m_currentProgram); |
| |
| glActiveTexture(m_activeTexture); |
| glBindTexture(GL_TEXTURE_2D, m_texBinding2D); |
| |
| // Restore bound element array buffer and array buffers |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_boundElementArrayBuffer); |
| for (int i = 0; i < m_maxVertexAttribs; i++) { |
| if (m_vertexAttribArrayEnabledStates[i]) |
| glEnableVertexAttribArray(i); |
| else |
| glDisableVertexAttribArray(i); |
| |
| glBindBuffer(GL_ARRAY_BUFFER, m_vertexAttribArrayBoundBuffers[i]); |
| glVertexAttribPointer(i, m_vertexAttribArraySizes[i], |
| m_vertexAttribArrayTypes[i], |
| m_vertexAttribArrayNormalized[i], |
| m_vertexAttribArrayStrides[i], |
| m_vertexAttribArrayOffsets[i]); |
| } |
| |
| glBindBuffer(GL_ARRAY_BUFFER, m_boundArrayBuffer); |
| |
| #ifdef VERBOSE_STATE_STORE |
| printCurrentState(false); |
| #endif |
| } |
| |
| void GLStateStore::initGLDefaultState() |
| { |
| #if !defined(QT_OPENGL_ES_2) |
| m_drawFramebuffer = 0; |
| m_readFramebuffer = 0; |
| m_renderbuffer = 0; |
| #endif |
| m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 1.0f; |
| m_clearDepth = 1.0f; |
| m_isBlendingEnabled = GL_FALSE; |
| m_isDepthTestEnabled = GL_FALSE; |
| m_depthFunc = GL_LESS; |
| m_isDepthWriteEnabled = GL_TRUE; |
| m_currentProgram = 0; |
| m_texBinding2D = 0; |
| for (int i = 0; i < m_maxVertexAttribs;i++) { |
| m_vertexAttribArrayEnabledStates[i] = GL_FALSE; |
| m_vertexAttribArrayBoundBuffers[i] = 0; |
| m_vertexAttribArraySizes[i] = 4; |
| m_vertexAttribArrayTypes[i] = GL_FLOAT; |
| m_vertexAttribArrayNormalized[i] = GL_FALSE; |
| m_vertexAttribArrayStrides[i] = 0; |
| m_vertexAttribArrayOffsets[i] = 0; |
| } |
| m_activeTexture = GL_TEXTURE0; |
| m_frontFace = GL_CCW; |
| m_isCullFaceEnabled = false; |
| m_cullFaceMode = GL_BACK; |
| m_blendEquationRGB = GL_FUNC_ADD; |
| m_blendEquationAlpha = GL_FUNC_ADD; |
| m_scissorBox[0] = 0; |
| m_scissorBox[1] = 0; |
| m_scissorBox[2] = 0; |
| m_scissorBox[3] = 0; |
| m_isScissorTestEnabled = GL_FALSE; |
| |
| m_polygonOffsetFillEnabled = GL_FALSE; |
| m_polygonOffsetFactor = 0.0; |
| m_polygonOffsetUnits = 0.0; |
| } |
