StelQGLRenderer.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 _STELQGLRENDERER_HPP_
#define _STELQGLRENDERER_HPP_


#include <QCache>
#include <QColor>
#include <QGLFunctions>
#include <QGraphicsView>
#include <QMap>
#include <QThread>

#include "GenericVertexTypes.hpp"
#include "StelApp.hpp"
#include "StelGuiBase.hpp"
#include "StelUtils.hpp"
#include "StelProjectorType.hpp"
#include "StelRenderer.hpp"
#include "StelQGLArrayVertexBufferBackend.hpp"
#include "StelQGLIndexBuffer.hpp"
#include "StelQGLTextureBackend.hpp"
#include "StelQGLViewport.hpp"
#include "StelTextureCache.hpp"
#include "StelVertexBuffer.hpp"

#define STELQGLRENDERER_MAX_TEXTURE_UNITS 64

enum QGLRendererStatistics
{
    ESTIMATED_TEXTURE_MEMORY     = 0,
    BATCHES                      = 1,
    EMPTY_BATCHES                = 2,
    BATCHES_TOTAL                = 3,
    VERTICES                     = 4,
    VERTICES_TOTAL               = 5,
    TRIANGLES                    = 6,
    TRIANGLES_TOTAL              = 7,
    LINES                        = 8,
    LINES_TOTAL                  = 9,
    FRAMES                       = 10,
    TEXT_DRAWS                   = 11,
    RECT_DRAWS                   = 12,
    GL_FPS                       = 13,
    BATCH_PROJECTIONS_NONE_TOTAL = 14,
    BATCH_PROJECTIONS_NONE       = 15,
    BATCH_PROJECTIONS_CPU_TOTAL  = 16,
    BATCH_PROJECTIONS_CPU        = 17,
    BATCH_PROJECTIONS_GPU_TOTAL  = 18,
    BATCH_PROJECTIONS_GPU        = 19,
    VERTEX_BUFFERS_CREATED       = 20,
    INDEX_BUFFERS_CREATED        = 21,
    TEXTURES_CREATED             = 22,
    SHADERS_CREATED              = 23
};

class StelQGLRenderer : public StelRenderer
{
public:
    StelQGLRenderer(QGraphicsView* const parent, const bool pvrSupported)
        : StelRenderer()
        , glContext(new QGLContext(QGLFormat(QGL::StencilBuffer | 
                                             QGL::DepthBuffer   |
                                             QGL::DoubleBuffer)))
        , viewport(new StelQGLWidget(glContext, parent), parent)
        , pvrSupported(pvrSupported)
        , textureCache()
        // Maximum bytes of text textures to store in the cache.
        // Increased for the Pulsars plugin.
        , textTextureCache(16777216)
        , textBuffer(NULL)
        , plainRectBuffer(NULL)
        , texturedRectBuffer(NULL)
        , previousFrameEndTime(-1.0)
        , globalColor(Qt::white)
        , depthTest(DepthTest_Disabled)
        , stencilTest(StencilTest_Disabled)
        , blendMode(BlendMode_None)
        , culledFaces(CullFace_None)
        , placeholderTexture(NULL)
        , currentFontSet(false)
        , textureUnitCount(-1)
        , gl(glContext)
    {
        loaderThread = new QThread();
        loaderThread->start(QThread::LowestPriority);
        for(int t = 0; t < STELQGLRENDERER_MAX_TEXTURE_UNITS; ++t)
        {
            currentlyBoundTextures[t] = NULL;
        }
    }
    
    virtual ~StelQGLRenderer()
    {
        invariant();
        loaderThread->quit();

        if(NULL != placeholderTexture)
        {
            delete placeholderTexture;
            placeholderTexture = NULL;
        }
        textTextureCache.clear();
        if(NULL != textBuffer) 
        {
            delete textBuffer;
            textBuffer = NULL;
        }
        if(NULL != texturedRectBuffer)
        {
            delete texturedRectBuffer;
            texturedRectBuffer = NULL;
        }
        if(NULL != plainRectBuffer)
        {
            delete plainRectBuffer;
            plainRectBuffer = NULL;
        }

        // This causes crashes for some reason 
        // (perhaps it is already destroyed by QT? - didn't find that in the docs).
        //
        // delete glContext;
        
        glContext   = NULL;

        loaderThread->wait();
        delete loaderThread;
        loaderThread = NULL;
    }
    
    virtual bool init()
    {
        // Can't call makeGLContextCurrent() before initialization is complete.
        glContext->makeCurrent();
        textureUnitCount = getTextureUnitCountBackend();
        glVendorString = QString(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
        qDebug() << "GL vendor is " << glVendorString;
        glRendererString = QString(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
        qDebug() << "GL renderer is " << glRendererString;
        viewport.init(gl.hasOpenGLFeature(QGLFunctions::NPOTTextures), 
                      glVendorString, glRendererString);
        initStatistics();
        return true;
    }
    
    virtual QImage screenshot()
    {
        invariant();
        return viewport.screenshot();
    }
    
    virtual void renderFrame(StelRenderClient& renderClient);

    virtual void viewportHasBeenResized(const QSize size)
    {
        invariant();
        viewport.viewportHasBeenResized(size);
        invariant();
    }

    virtual QSize getViewportSize() const 
    {
        invariant();
        return viewport.getViewportSize();
    }

    StelIndexBuffer* createIndexBuffer(const IndexType type)
    {
        statistics[INDEX_BUFFERS_CREATED] += 1.0;
        return new StelQGLIndexBuffer(type);
    }

    virtual void drawText(const TextParams& params);
    
    virtual void setFont(const QFont& font)
    {
        // The font is actually set only once drawing text.
        currentFont = font;
        currentFontSet = true;
    }

    virtual void bindTextureBackend(StelTextureBackend* const textureBackend, const int textureUnit);


    void ensureTextureNotBound(StelTextureBackend* const textureBackend)
    {
        for(int t = 0; t < STELQGLRENDERER_MAX_TEXTURE_UNITS; ++t)
        {
            if(currentlyBoundTextures[t] == textureBackend)
            {
                currentlyBoundTextures[t] = NULL;
                gl.glActiveTexture(GL_TEXTURE0 + t);
                glBindTexture(GL_TEXTURE_2D, 0);
            }
        }
    }

    virtual void destroyTextureBackend(StelTextureBackend* const textureBackend);

    virtual void setGlobalColor(const Vec4f& color)
    {
        globalColor = color;
    }

    virtual void setCulledFaces(const CullFace cullFace)
    {
        culledFaces = cullFace;
    }

    virtual void setBlendMode(const BlendMode mode)
    {
        blendMode = mode;
    }

    virtual void setDepthTest(const DepthTest test)
    {
        depthTest = test;
    }
    
    virtual void clearDepthBuffer()
    {
        // glDepthMask enables writing to the depth buffer so we can clear it.
        // This is a different API behavor from plain OpenGL. With OpenGL, the user 
        // must enable writing to the depth buffer to clear it.
        // StelRenderer allows it to be cleared regardless of modes set by setDepthTest
        // (which serves the same role as glDepthMask() in GL).
        glDepthMask(GL_TRUE);
        glClear(GL_DEPTH_BUFFER_BIT);
        glDepthMask(GL_FALSE);
    }

    virtual void setStencilTest(const StencilTest test)
    {
        stencilTest = test;
    }

    virtual void clearStencilBuffer()
    {
        glClearStencil(0);
        glClear(GL_STENCIL_BUFFER_BIT);
    }

    virtual void swapBuffers()
    {
        invariant();
        glContext->swapBuffers();
        invariant();
    }

    virtual void drawRect(const float x, const float y, 
                          const float width, const float height, 
                          const float angle = 0.0f);
    
    virtual void drawTexturedRect(const float x, const float y, 
                                  const float width, const float height, 
                                  const float angle = 0.0f);

    virtual StelRendererStatistics& getStatistics() 
    {
        return statistics;
    }

    virtual void makeGLContextCurrent()
    {
        invariant();
        if(Q_UNLIKELY(QGLContext::currentContext() != glContext))
        {
            // makeCurrent does not check if the context is already current, 
            // so it can really kill performance
            glContext->makeCurrent();
        }
        invariant();
    }

    QGLContext* getGLContext()
    {
        return glContext;
    }

    QGLFunctions& getGLFunctions()
    {
        return gl;
    }

    QThread* getLoaderThread()
    {
        return loaderThread;
    }

    const Vec4f& getGlobalColor() const
    {
        return globalColor;
    }

    virtual bool areNonPowerOfTwoTexturesSupported() const = 0;

    QPaintEngine::Type qtPaintEngineType() const 
    {
        return viewport.qtPaintEngineType();
    }

protected:
    QString glVendorString;

    QString glRendererString;

    StelRendererStatistics statistics;

    virtual StelTextureBackend* createTextureBackend
        (const QString& filename, const TextureParams& params, const TextureLoadingMode loadingMode);

    virtual StelTextureBackend* createTextureBackend
        (QImage& image, const TextureParams& params);

    virtual StelTextureBackend* createTextureBackend
        (const void* data, const QSize size, const TextureDataFormat format,
         const TextureParams& params);

    virtual StelTextureBackend* getViewportTextureBackend()
    {
        invariant();
        return viewport.getViewportTextureBackend(this);
    }
    
    virtual int getTextureUnitCountBackend()  = 0;

#ifndef NDEBUG
    virtual void invariant() const
    {
        Q_ASSERT_X(NULL != glContext, Q_FUNC_INFO,
                   "An attempt to use a destroyed StelQGLRenderer.");
        Q_ASSERT_X(glContext->isValid(), Q_FUNC_INFO, "The GL context is invalid");
    }
#else
    // This should guarantee this gets optimized away in release builds.
    void invariant() const{}
#endif

    void setupGLState(StelProjector* projector)
    {
        // Instead of setting GL state when functions such as setDepthTest() or setCulledFaces()
        // are called, we only set it before drawing and reset after drawing to avoid 
        // conflicts with e.g. Qt OpenGL backend, or any other GL code that might be running.
        //
        // Optimization note: 
        // Disabling GL state setup and reset improves performance by 3-8% 
        // (open source AMD driver), so that is the maximum speedup achievable 
        // by moving state setup into functions such as setBlendMode, setDepthTest, etc.

        // GL setup before drawing.
        // Fix some problem when using Qt OpenGL2 engine
        glStencilMask(0x11111111);
        
        // Moving this to drawVertexBufferBackend causes flicker issues
        switch(blendMode)
        {
            case BlendMode_None:
                glDisable(GL_BLEND);
                break;
            case BlendMode_Add:
                glBlendFunc(GL_ONE, GL_ONE);
                glEnable(GL_BLEND);
                break;
            case BlendMode_Alpha:
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                break;
            case BlendMode_Multiply:
                glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
                glEnable(GL_BLEND);
                break;
            default:
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown blend mode");
        }

        switch(depthTest)
        {
            case DepthTest_Disabled:
                glDisable(GL_DEPTH_TEST);
                break;
            case DepthTest_ReadOnly:
                glEnable(GL_DEPTH_TEST);
                glDepthMask(GL_FALSE);
                break;
            case DepthTest_ReadWrite:
                glEnable(GL_DEPTH_TEST);
                glDepthMask(GL_TRUE);
                break;
            default:
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown depth test mode");
        }

        switch(stencilTest)
        {
            case StencilTest_Disabled:
                glDisable(GL_STENCIL_TEST);
                break;
            case StencilTest_Write_1:
                glStencilFunc(GL_ALWAYS, 0x1, 0x1);
                glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
                glEnable(GL_STENCIL_TEST);
                break;
            case StencilTest_DrawIf_1:
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 0x1, 0x1);
                glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
                break;
            default:
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown stencil test mode");
        }

        switch(culledFaces)
        {
            case CullFace_None:
                glDisable(GL_CULL_FACE);
                break;
            case CullFace_Front:
                glEnable(GL_CULL_FACE);
                glCullFace(GL_FRONT);
                break;
            case CullFace_Back:
                glEnable(GL_CULL_FACE);
                glCullFace(GL_BACK);
                break;
            default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown cull face type");
        }
        
        glFrontFace(projector->flipFrontBackFace() ? GL_CW : GL_CCW);
    }
    
    void restoreGLState(StelProjector* projector)
    {
        // More stuff could be restored here if there are any Qt drawing problems.
        glFrontFace(projector->flipFrontBackFace() ? GL_CCW : GL_CW);
        glCullFace(GL_BACK);
        glDisable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_STENCIL_TEST);

        // Qt GL1 paint engine expects alpha blending to be enabled.
        //
        // If Qt fixes that, this might be removed.
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
    }

    template<class VBufferBackend>
    void updateDrawStatistics(VBufferBackend* vertexBuffer,
                              StelQGLIndexBuffer* indexBuffer)
    {
        statistics[BATCHES]           += 1.0;
        statistics[BATCHES_TOTAL]     += 1.0;

        const int vertices  = 
            (NULL == indexBuffer ? vertexBuffer->length() : indexBuffer->length());

        int triangles = 0;
        int lines     = 0;
        switch(vertexBuffer->getPrimitiveType())
        {
            case PrimitiveType_Points: 
                break;
            case PrimitiveType_Triangles:
                triangles = vertices / 3;
                break;
            case PrimitiveType_TriangleStrip:
            case PrimitiveType_TriangleFan:
                triangles = vertices >= 3 ? vertices - 2 : 0;
                break;
            case PrimitiveType_Lines: 
                lines = vertices / 2;
                break;
            case PrimitiveType_LineStrip:
                lines = vertices >= 2 ? vertices - 1 : 0;
                break;
            case PrimitiveType_LineLoop:
                lines = vertices;
                break;
            default:
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown graphics primitive type");
        }

        statistics[VERTICES]        += vertices;
        statistics[VERTICES_TOTAL]  += vertices;
        statistics[TRIANGLES]       += triangles;
        statistics[TRIANGLES_TOTAL] += triangles;
        statistics[LINES]           += lines;
        statistics[LINES_TOTAL]     += lines;
    }

private:
    struct FrameTimeQueue
    {
    public:
        FrameTimeQueue()
            : nextFrame(0)
        {
            memset(frames, '\0', FRAME_CAPACITY * sizeof(long double));
        }

        void update()
        {
            frames[nextFrame++] = StelUtils::secondsSinceStart();
            nextFrame = nextFrame % FRAME_CAPACITY;
        }

        double getFPS()
        {
            const long double newest = frames[(nextFrame - 1 + 256) % FRAME_CAPACITY];
            long double oldest = frames[nextFrame];
            Q_ASSERT_X(newest >= oldest, Q_FUNC_INFO, 
                          "Oldest frame time is more recent than newest");
            int tooOldCount = 0;
            // Don't compute FPS from more than one second of frames.
            while(newest - oldest > 1.0 && tooOldCount < FRAME_CAPACITY - 1)
            {
                ++tooOldCount;
                oldest = frames[(nextFrame + tooOldCount) % FRAME_CAPACITY];
            }
            return (FRAME_CAPACITY - tooOldCount) / (newest - oldest);
        }

    private:
        int nextFrame;

        static const int FRAME_CAPACITY = 128;

        long double frames[FRAME_CAPACITY];
    };

    QGLContext* glContext;

    StelQGLViewport viewport;
    
    bool pvrSupported;

    QThread* loaderThread;

    StelTextureCache<StelQGLTextureBackend> textureCache;

    QCache<QByteArray, StelQGLTextureBackend> textTextureCache;

    struct TexturedVertex
    {
        Vec2f position;
        Vec2f texCoord;
        TexturedVertex(const Vec2f& position, const Vec2f& texCoord)
            : position(position), texCoord(texCoord){}

        VERTEX_ATTRIBUTES(Vec2f Position, Vec2f TexCoord);
    };

    StelVertexBuffer<TexturedVertex>* textBuffer;

    StelVertexBuffer<VertexP2>* plainRectBuffer;

    StelVertexBuffer<TexturedVertex>* texturedRectBuffer;
    
    double previousFrameEndTime;

    Vec4f globalColor;

    DepthTest depthTest;

    StencilTest stencilTest;

    BlendMode blendMode;

    CullFace culledFaces;

    StelQGLTextureBackend* placeholderTexture;

    StelQGLTextureBackend* currentlyBoundTextures[STELQGLRENDERER_MAX_TEXTURE_UNITS];

    QFont currentFont;

    bool currentFontSet;

    int textureUnitCount;

    FrameTimeQueue recentFrames;

    void drawWindow(StelViewportEffect* const effect);
    
    void initStatistics()
    {
        // NOTE: Order of statistics added here _must_ match the order 
        // of values of the QGLRendererStatistics enum.
        statistics.addStatistic("estimated_texture_memory");

        // Draw statistics
        statistics.addStatistic("batches", StatisticSwapMode_SetToZero);
        statistics.addStatistic("empty_batches", StatisticSwapMode_SetToZero);
        statistics.addStatistic("batches_total");
        statistics.addStatistic("vertices", StatisticSwapMode_SetToZero);
        statistics.addStatistic("vertices_total");
        statistics.addStatistic("triangles", StatisticSwapMode_SetToZero);
        statistics.addStatistic("triangles_total");
        statistics.addStatistic("lines", StatisticSwapMode_SetToZero);
        statistics.addStatistic("lines_total");
        statistics.addStatistic("frames");
        statistics.addStatistic("text_draws", StatisticSwapMode_SetToZero);
        statistics.addStatistic("rect_draws", StatisticSwapMode_SetToZero);
        statistics.addStatistic("gl_fps");

        // Projection statistics
        statistics.addStatistic("batch_projections_none_total");
        statistics.addStatistic("batch_projections_none", StatisticSwapMode_SetToZero);
        statistics.addStatistic("batch_projections_cpu_total");
        statistics.addStatistic("batch_projections_cpu", StatisticSwapMode_SetToZero);
        statistics.addStatistic("batch_projections_gpu_total");
        statistics.addStatistic("batch_projections_gpu", StatisticSwapMode_SetToZero);

        // Creation of Renderer objects
        statistics.addStatistic("vertex_buffers_created");
        statistics.addStatistic("index_buffers_created");
        statistics.addStatistic("textures_created");
        statistics.addStatistic("shaders_created");
    }

    void clearFrameStatistics()
    {
        statistics.swap();
        statistics[FRAMES] += 1.0;
        statistics[GL_FPS] = recentFrames.getFPS();
    }

    void drawTextGravityHelper
        (const TextParams& params, QPainter& painter, const int baseX, const int baseY, StelProjectorP projector);

    StelQGLTextureBackend* getPlaceholderTexture(bool debug=false)
    {
        if(NULL != placeholderTexture) {return placeholderTexture;}

        int color = 0;
        if (debug)
            color = 0x00FFFF00;

        const int placeholderSize = 512;
        const int cellSize = 16;
        QImage image(placeholderSize, placeholderSize, QImage::Format_RGB888);
        for(int y = 0; y < placeholderSize; ++y)
        {
            for (int x = 0; x < placeholderSize; x++) 
            {
                image.setPixel(x, y, (x / cellSize) % 2 == (y / cellSize) % 2 ? 0 : color);
            }
        }
        placeholderTexture = 
            StelQGLTextureBackend::constructFromImage(this, QString(), TextureParams(), image);

        return placeholderTexture;
    }

    void drawRectInternal(const bool textured, const float x, const float y, 
                          const float width, const float height, const float angle);

    // Must be down due to initializer list order.
protected:
    QGLFunctions gl;
};

#endif // _STELQGLRENDERER_HPP_