StelQGLViewport.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELQGLVIEWPORT_HPP_
#define _STELQGLVIEWPORT_HPP_

#include <QGLFramebufferObject>
#include <QGLWidget>
#include <QGraphicsView>
#include <QImage>
#include <QPainter>

#include "StelUtils.hpp"

class StelQGLWidget : public QGLWidget
{
public:
    StelQGLWidget(QGLContext* ctx, QWidget* parent) : QGLWidget(ctx, parent)
    {
        setAttribute(Qt::WA_PaintOnScreen);
        setAttribute(Qt::WA_NoSystemBackground);
        setAttribute(Qt::WA_OpaquePaintEvent);
        //setAutoFillBackground(false);
        setBackgroundRole(QPalette::Window);
    }

    QPaintEngine::Type getPaintEngineType() const
    {
        return paintEngineType;
    }

protected:
    virtual void initializeGL()
    {
        qDebug() << "OpenGL supported version: " << QString((char*)glGetString(GL_VERSION));

        QGLWidget::initializeGL();

        if (!format().stencil())
            qWarning("Could not get stencil buffer; results will be suboptimal");
        if (!format().depth())
            qWarning("Could not get depth buffer; results will be suboptimal");
        if (!format().doubleBuffer())
            qWarning("Could not get double buffer; results will be suboptimal");

        QString paintEngineStr;
        paintEngineType = paintEngine()->type();
        switch (paintEngineType)
        {
            case QPaintEngine::OpenGL:  paintEngineStr = "OpenGL"; break;
            case QPaintEngine::OpenGL2: paintEngineStr = "OpenGL2"; break;
            default:                    paintEngineStr = "Other";
        }
        qDebug() << "Qt GL paint engine is: " << paintEngineStr;
    }

    QPaintEngine::Type paintEngineType;
};

class StelQGLViewport
{
public:
    StelQGLViewport(StelQGLWidget* const glWidget, QGraphicsView* const parent)
        : viewportSize(QSize())
        , glWidget(glWidget)
        , painter(NULL)
        , defaultPainter(NULL)
        , backBufferPainter(NULL)
        , frontBuffer(NULL)
        , backBuffer(NULL)
        , drawing(false)
        , usingGLWidgetPainter(false)
        , fboSupported(false)
        , fboDisabled(false)
        , nonPowerOfTwoTexturesSupported(false)
    {
        // Forces glWidget to initialize GL.
        glWidget->updateGL();

        // Qt GL2 paint engine does some FBO magic depending 
        // on glBlendFunc having a particular value. I wasn't able 
        // to figure out what value it was, so another workaround 
        // was to not use FBOs ourselves.
        // Not sure _why exactly_ this helps though.
        //
        // TODO
        // If Qt is newer than 4.0, try removing this if - 
        // FBOs are an important feature so we want to use it 
        // if the Qt people cleaned up their mess.
        if(qtPaintEngineType() == QPaintEngine::OpenGL2)
        {
            fboDisabled = true;
        }
        parent->setViewport(glWidget);
        invariant();
    }

    ~StelQGLViewport()
    {
        invariant();
        Q_ASSERT_X(NULL == this->painter, Q_FUNC_INFO, 
                   "Painting is not disabled at destruction");

        destroyFBOs();
        // No need to delete the GL widget, its parent widget will do that.
        glWidget = NULL;
    }

    void init(const bool npot, const QString& glVendor, const QString& glRenderer)
    {
        invariant();
        this->nonPowerOfTwoTexturesSupported = npot;
        // Prevent flickering on mac Leopard/Snow Leopard
        glWidget->setAutoFillBackground(false);

        // In some virtual machines.
        // Not all needed FBO functionality needed is supported.
        if(glRenderer == "Chromium")
        {
            fboDisabled = true;
        }
        if(glVendor == "Tungsten Graphics, Inc")
        {
            if(glRenderer.contains("945") || 
               glRenderer.contains("810") || 
               glRenderer.contains("845") || 
               glRenderer.contains("855") || 
               glRenderer.contains("865") || 
               glRenderer.contains("915") || 
               glRenderer.contains("946") || 
               glRenderer.contains("500") || 
               glRenderer.contains("965") || 
               glRenderer.contains("950") || 
               glRenderer.contains("X3100") || 
               glRenderer.contains("GM45") || 
               glRenderer.contains("Ironlake") || 
               glRenderer.contains("G33") || 
               glRenderer.contains("G41") || 
               glRenderer.contains("IGD"))
            {
                fboDisabled = true;
            }
        }

        fboSupported = QGLFramebufferObject::hasOpenGLFramebufferObjects();
        invariant();
    }

    QPaintEngine::Type qtPaintEngineType() const
    {
        return glWidget->getPaintEngineType();
    }

    void viewportHasBeenResized(const QSize newSize)
    {
        invariant();
        //Can't check this in invariant because Renderer is initialized before 
        //AppGraphicsWidget sets its viewport size
        Q_ASSERT_X(newSize.isValid(), Q_FUNC_INFO, "Invalid scene size");
        viewportSize = newSize;
        //We'll need FBOs of different size so get rid of the current FBOs.
        destroyFBOs();
        invariant();
    }
    
    void setDefaultPainter(QPainter* const painter, const QGLContext* const context)
    {
        invariant();

#ifndef NDEBUG
        if(NULL != painter)
        {
            Q_ASSERT_X(painter->paintEngine()->type() == QPaintEngine::OpenGL ||
                       painter->paintEngine()->type() == QPaintEngine::OpenGL2,
                       Q_FUNC_INFO, 
                       "QGL StelRenderer backends need a QGLWidget to be set as the "
                       "viewport on the graphics view");
            QGLWidget* widget = dynamic_cast<QGLWidget*>(painter->device());
            Q_ASSERT_X(NULL != widget && widget->context() == context, Q_FUNC_INFO,
                       "Painter used with QGL StelRenderer backends needs to paint on a QGLWidget "
                       "with the same GL context as the one used by the renderer");
        }
#else
        Q_UNUSED(context);
#endif

        defaultPainter = painter;
        invariant();
    }

    QImage screenshot() const 
    {
        invariant();
        return glWidget->grabFrameBuffer();
    }

    QSize getViewportSize() const 
    {
        invariant();
        return viewportSize;
    }

    StelTextureBackend* getViewportTextureBackend(class StelQGLRenderer* renderer);

    bool useFBO() const
    {
        // Can't call invariant here as invariant calls useFBO
        return fboSupported && !fboDisabled;
    }

    void setFont(const QFont& font)
    {
        Q_ASSERT_X(NULL != painter, Q_FUNC_INFO,
                   "Trying to set text (painting) font but painting is disabled");
        painter->setFont(font);
    }

    void startFrame()
    {
        invariant();
        if (useFBO())
        {
            //Draw to backBuffer.
            initFBOs();
            backBuffer->bind();
            backBufferPainter = new QPainter(backBuffer);
            enablePainting(backBufferPainter);
        }
        else
        {
            enablePainting();
        }
        drawing = true;
        invariant();
    }

    void suspendFrame() 
    {
        Q_ASSERT_X(useFBO(), Q_FUNC_INFO, "Partial rendering only works with FBOs");
        finishFrame(false);
    }
    
    void finishFrame(const bool swapBuffers = true)
    {
        invariant();
        drawing = false;

        disablePainting();
        
        if (useFBO())
        {
            //Release the backbuffer.
            delete backBufferPainter;
            backBufferPainter = NULL;

            backBuffer->release();
            //Swap buffers if finishing, don't swap yet if suspending.
            if(swapBuffers){swapFBOs();}
        }
        invariant();
    }

    void prepareToDrawViewport()
    {
        invariant();
        //Put the result of drawing to the FBO on the screen, applying an effect.
        if (useFBO())
        {
            Q_ASSERT_X(!backBuffer->isBound() && !frontBuffer->isBound(), Q_FUNC_INFO, 
                       "Framebuffer objects weren't released before drawing the result");
        }
    }

    void disablePainting()
    {
        invariant();
        
        if(usingGLWidgetPainter)
        {
            delete painter;
            usingGLWidgetPainter = false;
        }
        painter = NULL;
        invariant();
    }

    void enablePainting()
    {
        invariant();
        enablePainting(defaultPainter);
        invariant();
    }

    QPainter* getPainter()
    {
        return painter;
    }

private:
    QSize viewportSize;
    StelQGLWidget* glWidget;

    QPainter* painter;
    QPainter* defaultPainter;
    QPainter* backBufferPainter;

    QGLFramebufferObject* frontBuffer;
    QGLFramebufferObject* backBuffer;

    bool drawing;

    bool usingGLWidgetPainter;

    bool fboSupported;
    bool fboDisabled;

    bool nonPowerOfTwoTexturesSupported;

    void invariant() const
    {
#ifndef NDEBUG
        Q_ASSERT_X(NULL != glWidget, Q_FUNC_INFO, "Destroyed StelQGLViewport");
        Q_ASSERT_X(glWidget->isValid(), Q_FUNC_INFO, 
                   "Invalid glWidget (maybe there is no OpenGL support?)");

        const bool fbo = useFBO();
        Q_ASSERT_X(NULL == backBufferPainter || fbo, Q_FUNC_INFO,
                   "We have a backbuffer painter even though we're not using FBO");
        Q_ASSERT_X(drawing && fbo ? backBufferPainter != NULL : true, Q_FUNC_INFO,
                   "We're drawing and using FBOs, but the backBufferPainter is NULL");
        Q_ASSERT_X(NULL == backBuffer || fbo, Q_FUNC_INFO,
                   "We have a backbuffer even though we're not using FBO");
        Q_ASSERT_X(NULL == frontBuffer || fbo, Q_FUNC_INFO,
                   "We have a frontbuffer even though we're not using FBO");
        Q_ASSERT_X(drawing && fbo ? backBuffer != NULL : true, Q_FUNC_INFO,
                   "We're drawing and using FBOs, but the backBuffer is NULL");
        Q_ASSERT_X(drawing && fbo ? frontBuffer != NULL : true, Q_FUNC_INFO,
                   "We're drawing and using FBOs, but the frontBuffer is NULL");
#endif
    }

    void enablePainting(QPainter* painter)
    {
        invariant();
        
        // If no painter specified, create a default one painting to the glWidget.
        if(painter == NULL)
        {
            this->painter = new QPainter(glWidget);
            usingGLWidgetPainter = true;
            return;
        }
        this->painter = painter;
        invariant();
    }

    void initFBOs()
    {
        invariant();
        Q_ASSERT_X(useFBO(), Q_FUNC_INFO, "We're not using FBO");
        if (NULL == backBuffer)
        {
            Q_ASSERT_X(NULL == frontBuffer, Q_FUNC_INFO, 
                       "frontBuffer is not null even though backBuffer is");

            // If non-power-of-two textures are supported,
            // FBOs must have power of two size large enough to fit the viewport.
            const QSize bufferSize = nonPowerOfTwoTexturesSupported 
                ? StelUtils::smallestPowerOfTwoSizeGreaterOrEqualTo(viewportSize) 
                : viewportSize;

            // We want a depth and stencil buffer attached to our FBO if possible.
            const QGLFramebufferObject::Attachment attachment =
                QGLFramebufferObject::CombinedDepthStencil;
            backBuffer  = new QGLFramebufferObject(bufferSize, attachment);
            frontBuffer = new QGLFramebufferObject(bufferSize, attachment);

            Q_ASSERT_X(backBuffer->isValid() && frontBuffer->isValid(),
                       Q_FUNC_INFO, "Framebuffer objects failed to initialize");
        }
        invariant();
    }
    
    void swapFBOs()
    {
        invariant();
        Q_ASSERT_X(useFBO(), Q_FUNC_INFO, "We're not using FBO");
        QGLFramebufferObject* tmp = backBuffer;
        backBuffer = frontBuffer;
        frontBuffer = tmp;
        invariant();
    }

    void destroyFBOs()
    {
        invariant();
        // Destroy framebuffers
        if(NULL != frontBuffer)
        {
            delete frontBuffer;
            frontBuffer = NULL;
        }
        if(NULL != backBuffer)
        {
            delete backBuffer;
            backBuffer = NULL;
        }
        invariant();
    }
};

#endif // _STELQGLVIEWPORT_HPP_