Stellarium 0.11.4
		Home · All Namespaces · All Classes · Functions · Coding Style · Scripting · Plugins · File Structure

core/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 "VecMath.hpp"
#include "StelSphereGeometry.hpp"
#include "StelProjectorType.hpp"
#include "StelProjector.hpp"
#include <QString>
#include <QVarLengthArray>
#include <QFontMetrics>

#ifdef USE_OPENGL_ES2
 #define STELPAINTER_GL2 1
#endif

#ifdef STELPAINTER_GL2
class QGLShaderProgram;
#endif

class QPainter;
class QGLContext;

class StelPainterLight
{
public:
    StelPainterLight(int alight=0) : light(alight), enabled(false) {}

    void setPosition(const Vec4f& v);
    Vec4f& getPosition() {return position;}

    void setDiffuse(const Vec4f& v);
    Vec4f& getDiffuse() {return diffuse;}

    void setSpecular(const Vec4f& v);
    Vec4f& getSpecular() {return specular;}

    void setAmbient(const Vec4f& v);
    Vec4f& getAmbient() {return ambient;}

    void setEnable(bool v);
    void enable();
    void disable();
    bool isEnabled() const {return enabled;}

private:
    int light;
    Vec4f position;
    Vec4f diffuse;
    Vec4f specular;
    Vec4f ambient;
    bool enabled;
};


class StelPainterMaterial
{
public:
    StelPainterMaterial();

    void setSpecular(const Vec4f& v);
    Vec4f& getSpecular() {return specular;}

    void setAmbient(const Vec4f& v);
    Vec4f& getAmbient() {return ambient;}

    void setEmission(const Vec4f& v);
    Vec4f& getEmission() {return emission;}

    void setShininess(float v);
    float getShininess() {return shininess;}
private:
    Vec4f specular;
    Vec4f ambient;
    Vec4f emission;
    float shininess;
};

class StelPainter
{
public:
    friend class VertexArrayProjector;

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

    enum ShadeModel
    {
        ShadeModelFlat=0x1D00,      
        ShadeModelSmooth=0x1D01 
    };

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

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

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

    void drawViewportShape();

    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=NULL, bool doSubDivise=true, double maxSqDistortion=5.);

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

    void drawSphericalTriangles(const StelVertexArray& va, bool textured, const SphericalCap* clippingCap=NULL, 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)=NULL, void* userData=NULL);

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

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

    void drawSprite2dMode(float x, float y, float radius);
    void drawSprite2dMode(const Vec3d& v, 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);

    static StelVertexArray computeSphereNoLight(float radius, float oneMinusOblateness, int slices, int stacks, int orientInside = 0, bool flipTexture = false);

    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 sRing(float rMin, float rMax, int slices, int stacks, int orientInside);

    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;

    StelPainterLight& getLight() {return light;}

    StelPainterMaterial& getMaterial() {return material;}

    QFontMetrics getFontMetrics() const;

    static void initSystemGLInfo(QGLContext* ctx);

    static void setQPainter(QPainter* qPainter);

    static void swapBuffer();

    static void makeMainGLContextCurrent();

    // The following methods try to reflect the API of the incoming QGLPainter class

    void setPointSize(qreal size);

    void setShadeModel(ShadeModel m);

    void enableTexture2d(bool b);

    // 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* vertice, const Vec2f* texCoords=NULL, const Vec3f* colorArray=NULL, const Vec3f* normalArray=NULL);

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

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

private:

    friend class StelTextureMgr;
    friend class StelTexture;
    typedef struct
    {
        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 int* indices=NULL);

    void projectSphericalTriangle(const SphericalCap* clippingCap, const Vec3d* vertices, QVarLengthArray<Vec3f, 4096>* outVertices,
            const Vec2f* texturePos=NULL, QVarLengthArray<Vec2f, 4096>* outTexturePos=NULL, 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;
    void drawSmallCircleVertexArray();

    StelProjectorP prj;

#ifndef NDEBUG

    static class QMutex* globalMutex;
#endif

    static QPainter* qPainter;

    static QGLContext* glContext;

    static bool isNoPowerOfTwoAllowed;

#ifdef STELPAINTER_GL2
    Vec4f currentColor;
    bool texture2dEnabled;
    static QGLShaderProgram* basicShaderProgram;
    struct BasicShaderVars {
        int projectionMatrix;
        int color;
        int vertex;
    };
    static BasicShaderVars basicShaderVars;
    static QGLShaderProgram* colorShaderProgram;
    static QGLShaderProgram* texturesShaderProgram;
    struct TexturesShaderVars {
        int projectionMatrix;
        int texCoord;
        int vertex;
        int texColor;
        int texture;
    };
    static TexturesShaderVars texturesShaderVars;
    static QGLShaderProgram* texturesColorShaderProgram;
    struct TexturesColorShaderVars {
        int projectionMatrix;
        int texCoord;
        int vertex;
        int color;
        int texture;
    };
    static TexturesColorShaderVars texturesColorShaderVars;
#endif

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

    StelPainterLight light;

    StelPainterMaterial material;
};

#endif // _STELPAINTER_HPP_

---