StelPainter.hpp

/*
 * Stellarium
 * Copyright (C) 2008 Fabien Chereau
 *
 * 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 _STELPAINTER_HPP_
#define _STELPAINTER_HPP_

#include "StelOpenGL.hpp"
#include "VecMath.hpp"
#include "StelSphereGeometry.hpp"
#include "StelProjectorType.hpp"
#include "StelProjector.hpp"
#include <QString>
#include <QVarLengthArray>
#include <QFontMetrics>

class QOpenGLShaderProgram;

class StelPainter : protected QOpenGLFunctions
{
public:
    friend class VertexArrayProjector;

    enum SphericalPolygonDrawMode
    {
        SphericalPolygonDrawModeFill=0,             
        SphericalPolygonDrawModeBoundary=1,         
        SphericalPolygonDrawModeTextureFill=2,          
        SphericalPolygonDrawModeTextureFillColormodulated=3 
    };

    enum DrawingMode
    {
        Points                      = 0x0000, 
        Lines                       = 0x0001, 
        LineLoop                    = 0x0002, 
        LineStrip                   = 0x0003, 
        Triangles                   = 0x0004, 
        TriangleStrip               = 0x0005, 
        TriangleFan                 = 0x0006  
    };

    explicit StelPainter(const StelProjectorP& prj);
    ~StelPainter();

    inline QOpenGLFunctions* glFuncs() { return this; }

    const StelProjectorP& getProjector() const {return prj;}
    void setProjector(const StelProjectorP& p);

    void drawViewportShape(void);

    void drawText(float x, float y, const QString& str, float angleDeg=0.f,
              float xshift=0.f, float yshift=0.f, bool noGravity=true);
    void drawText(const Vec3d& v, const QString& str, float angleDeg=0.f,
              float xshift=0.f, float yshift=0.f, bool noGravity=true);

    void drawSphericalRegion(const SphericalRegion* region, SphericalPolygonDrawMode drawMode=SphericalPolygonDrawModeFill, const SphericalCap* clippingCap=Q_NULLPTR, bool doSubDivise=true, double maxSqDistortion=5.);

    void drawGreatCircleArcs(const StelVertexArray& va, const SphericalCap* clippingCap=Q_NULLPTR);

    void drawSphericalTriangles(const StelVertexArray& va, bool textured, bool colored, const SphericalCap* clippingCap=Q_NULLPTR, bool doSubDivide=true, double maxSqDistortion=5.);

    void drawSmallCircleArc(const Vec3d& start, const Vec3d& stop, const Vec3d& rotCenter, void (*viewportEdgeIntersectCallback)(const Vec3d& screenPos, const Vec3d& direction, void* userData)=Q_NULLPTR, void* userData=Q_NULLPTR);

    void drawGreatCircleArc(const Vec3d& start, const Vec3d& stop, const SphericalCap* clippingCap=Q_NULLPTR, void (*viewportEdgeIntersectCallback)(const Vec3d& screenPos, const Vec3d& direction, void* userData)=Q_NULLPTR, void* userData=Q_NULLPTR);

    void drawPath(const QVector<Vec3d> &points, const QVector<Vec4f> &colors);

    void drawCircle(float x, float y, float r);

    void drawSprite2dMode(float x, float y, float radius);
    void drawSprite2dMode(const Vec3d& v, float radius);

    void drawSprite2dModeNoDeviceScale(float x, float y, float radius);
    
    void drawSprite2dMode(float x, float y, float radius, float rotation);

    void drawPoint2d(float x, float y);

    void drawLine2d(float x1, float y1, float x2, float y2);

    void drawRect2d(float x, float y, float width, float height, bool textured=true);

    void sSphere(float radius, float oneMinusOblateness, int slices, int stacks, int orientInside = 0, bool flipTexture = false,
                 float topAngle=0.0f, float bottomAngle=M_PI);

    static StelVertexArray computeSphereNoLight(float radius, float oneMinusOblateness, int slices, int stacks,
                            int orientInside = 0, bool flipTexture = false,
                            float topAngle=0.0f, float bottomAngle=M_PI);

    void sCylinder(float radius, float height, int slices, int orientInside = 0);

    static void computeFanDisk(float radius, int innerFanSlices, int level, QVector<double>& vertexArr, QVector<float>& texCoordArr);

    void sSphereMap(float radius, int slices, int stacks, float textureFov = 2.f*M_PI, int orientInside = 0);

    void setFont(const QFont& font);

    void setColor(float r, float g, float b, float a=1.f);

    Vec4f getColor() const;

    QFontMetrics getFontMetrics() const;

    void setBlending(bool enableBlending, GLenum blendSrc = GL_SRC_ALPHA, GLenum blendDst = GL_ONE_MINUS_SRC_ALPHA);

    void setDepthTest(bool enable);

    void setDepthMask(bool enable);

    void setCullFace(bool enable);

    void setLineSmooth(bool enable);

    void setLineWidth(float width);

    static void initGLShaders();
    
    static void deinitGLShaders();

    // Thoses methods should eventually be replaced by a single setVertexArray
    void setVertexPointer(int size, int type, const void* pointer) {
        vertexArray.size = size; vertexArray.type = type; vertexArray.pointer = pointer;
    }

    void setTexCoordPointer(int size, int type, const void* pointer)
    {
        texCoordArray.size = size; texCoordArray.type = type; texCoordArray.pointer = pointer;
    }

    void setColorPointer(int size, int type, const void* pointer)
    {
        colorArray.size = size; colorArray.type = type; colorArray.pointer = pointer;
    }

    void setNormalPointer(int type, const void* pointer)
    {
        normalArray.size = 3; normalArray.type = type; normalArray.pointer = pointer;
    }

    void enableClientStates(bool vertex, bool texture=false, bool color=false, bool normal=false);

    void setArrays(const Vec3d* vertices, const Vec2f* texCoords=Q_NULLPTR, const Vec3f* colorArray=Q_NULLPTR, const Vec3f* normalArray=Q_NULLPTR);
    void setArrays(const Vec3f* vertices, const Vec2f* texCoords=Q_NULLPTR, const Vec3f* colorArray=Q_NULLPTR, const Vec3f* normalArray=Q_NULLPTR);

    void drawFromArray(DrawingMode mode, int count, int offset=0, bool doProj=true, const unsigned short *indices=Q_NULLPTR);

    void drawStelVertexArray(const StelVertexArray& arr, bool checkDiscontinuity=true);

    static bool linkProg(class QOpenGLShaderProgram* prog, const QString& name);

private:

    friend class StelTextureMgr;
    friend class StelTexture;

    struct GLState
    {
        GLState(QOpenGLFunctions *gl);

        bool blend;
        GLenum blendSrc, blendDst;
        bool depthTest;
        bool depthMask;
        bool cullFace;
        bool lineSmooth;
        GLfloat lineWidth;

        void apply();
        void reset();
    private:
        QOpenGLFunctions* gl;
    } glState;

    // From text-use-opengl-buffer
    static QCache<QByteArray, struct StringTexture> texCache;
    struct StringTexture* getTexTexture(const QString& str, int pixelSize);

    typedef struct ArrayDesc
    {
        ArrayDesc() : size(0), type(0), pointer(Q_NULLPTR), enabled(false) {}
        int size;               // The number of coordinates per vertex.
        int type;               // The data type of each coordinate (GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE).
        const void* pointer;    // Pointer to the first coordinate of the first vertex in the array.
        bool enabled;           // Define whether the array is enabled or not.
    } ArrayDesc;

    ArrayDesc projectArray(const ArrayDesc& array, int offset, int count, const unsigned short *indices=Q_NULLPTR);

    void projectSphericalTriangle(const SphericalCap* clippingCap, const Vec3d* vertices, QVarLengthArray<Vec3f, 4096>* outVertices,
            const Vec2f* texturePos=Q_NULLPTR, QVarLengthArray<Vec2f, 4096>* outTexturePos=Q_NULLPTR,
            const Vec3f* colors=Q_NULLPTR, QVarLengthArray<Vec3f, 4096>* outColors=Q_NULLPTR,
            double maxSqDistortion=5., int nbI=0,
            bool checkDisc1=true, bool checkDisc2=true, bool checkDisc3=true) const;

    void drawTextGravity180(float x, float y, const QString& str, float xshift = 0, float yshift = 0);

    // Used by the method below
    static QVector<Vec2f> smallCircleVertexArray;
    static QVector<Vec4f> smallCircleColorArray;
    void drawSmallCircleVertexArray();

    StelProjectorP prj;

#ifndef NDEBUG
    static class QMutex* globalMutex;
#endif

    QFont currentFont;

    Vec4f currentColor;
    
    static QOpenGLShaderProgram* basicShaderProgram;
    struct BasicShaderVars {
        int projectionMatrix;
        int color;
        int vertex;
    };
    static BasicShaderVars basicShaderVars;

    static QOpenGLShaderProgram* colorShaderProgram;
    static BasicShaderVars colorShaderVars;

    static QOpenGLShaderProgram* texturesShaderProgram;
    struct TexturesShaderVars {
        int projectionMatrix;
        int texCoord;
        int vertex;
        int texColor;
        int texture;
    };
    static TexturesShaderVars texturesShaderVars;
    static QOpenGLShaderProgram* texturesColorShaderProgram;
    struct TexturesColorShaderVars {
        int projectionMatrix;
        int texCoord;
        int vertex;
        int color;
        int texture;
    };
    static TexturesColorShaderVars texturesColorShaderVars;


    ArrayDesc vertexArray;
    ArrayDesc texCoordArray;
    ArrayDesc normalArray;
    ArrayDesc colorArray;
};

#endif // _STELPAINTER_HPP_