StelProjector.hpp

/*
 * Stellarium
 * Copyright (C) 2003 Fabien Chereau
 * Copyright (C) 2012 Matthew Gates
 *
 * 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 _STELPROJECTOR_HPP_
#define _STELPROJECTOR_HPP_

#include "StelProjectorType.hpp"
#include "VecMath.hpp"
#include "StelSphereGeometry.hpp"
#include "renderer/StelGLSLShader.hpp"


class StelProjector
{
public:
    friend class StelCore;

    class GLSLProjector
    {
    public:
        virtual bool init(class StelGLSLShader* shader) = 0;

        virtual void preDraw(class StelGLSLShader* shader) = 0;

        virtual void postDraw(class StelGLSLShader* shader) = 0;
    };

    class ModelViewTranform;
    typedef QSharedPointer<ModelViewTranform> ModelViewTranformP;

    class ModelViewTranform
    {
    public:
        ModelViewTranform() {;}
        virtual ~ModelViewTranform() {;}
        virtual void forward(Vec3d&) const =0;
        virtual void backward(Vec3d&) const =0;
        virtual void forward(Vec3f&) const =0;
        virtual void backward(Vec3f&) const =0;

        virtual void combine(const Mat4d&)=0;
        virtual ModelViewTranformP clone() const=0;

        virtual bool setupGLSLTransform(class StelGLSLShader* shader) = 0;

        virtual void setGLSLUniforms(class StelGLSLShader* shader) = 0;

        virtual void disableGLSLTransform(class StelGLSLShader* shader) = 0;

        virtual Mat4d getApproximateLinearTransfo() const=0;
    };

    class Mat4dTransform: public ModelViewTranform
    {
    public:
        Mat4dTransform(const Mat4d& m);
        void forward(Vec3d& v) const;
        void backward(Vec3d& v) const;
        void forward(Vec3f& v) const;
        void backward(Vec3f& v) const;
        void combine(const Mat4d& m);
        Mat4d getApproximateLinearTransfo() const;
        ModelViewTranformP clone() const;

        virtual bool setupGLSLTransform(StelGLSLShader* shader)
        {
            if(!shader->hasVertexShader("Mat4dTransform"))
            {
                static const QString source(
                    "uniform mat4 modelViewMatrix;\n"
                    "\n"
                    "vec4 modelViewForward(in vec4 v)\n"
                    "{\n"
                    "   return modelViewMatrix * v;\n"
                    "}\n");

                if(!shader->addVertexShader("Mat4dTransform", source))
                {
                    return false;
                }
                qDebug() << "Build log after adding a Mat4d transform shader: "
                         << shader->log();
            }
            shader->enableVertexShader("Mat4dTransform");
            return true;
        }

        virtual void setGLSLUniforms(StelGLSLShader* shader)
        {
            shader->setUniformValue("modelViewMatrix", transfoMatf);
        }

        virtual void disableGLSLTransform(StelGLSLShader* shader)
        {
            shader->disableVertexShader("Mat4dTransform");
        }

    private:
        Mat4d transfoMat;
        Mat4f transfoMatf;
    };

    enum StelProjectorMaskType
    {
        MaskNone,   
        MaskDisk    
    };

    struct StelProjectorParams
    {
        StelProjectorParams() : viewportXywh(0, 0, 256, 256), fov(60.f), gravityLabels(false), defautAngleForGravityText(0.f), maskType(MaskNone), viewportCenter(128.f, 128.f), flipHorz(false), flipVert(false) {;}
        Vector4<int> viewportXywh;      
        float fov;                      
        bool gravityLabels;             
        float defautAngleForGravityText;
        StelProjectorMaskType maskType; 
        float zNear, zFar;              
        Vec2f viewportCenter;           
        float viewportFovDiameter;      
        bool flipHorz, flipVert;        
    };

    virtual ~StelProjector() {}

    // Methods which must be reimplemented by all instance of StelProjector
    virtual QString getNameI18() const = 0;
    virtual QString getDescriptionI18() const {return "No description";}
    QString getHtmlSummary() const;
    virtual float getMaxFov() const = 0;
    virtual bool forward(Vec3f& v) const = 0;
    virtual bool backward(Vec3d& v) const = 0;
    virtual float deltaZoom(float fov) const = 0;

    bool intersectViewportDiscontinuity(const Vec3d& p1, const Vec3d& p2) const;
    bool intersectViewportDiscontinuity(const SphericalCap& cap) const;

    virtual float fovToViewScalingFactor(float fov) const = 0;
    virtual float viewScalingFactorToFov(float vsf) const = 0;

    bool getFlagGravityLabels() const;

    const Vec4i& getViewport() const;

    Vec2f getViewportCenter() const;

    int getViewportPosX() const;
    int getViewportPosY() const;
    int getViewportWidth() const;
    int getViewportHeight() const;

    SphericalRegionP getViewportConvexPolygon(float marginX=0., float marginY=0.) const;

    const SphericalCap& getBoundingCap() const;

    float getPixelPerRadAtCenter() const;

    float getFov() const;

    bool flipFrontBackFace() const
    {
        // Moved to header for inlining
        return (flipHorz*flipVert < 0.f);
    }

    // Full projection methods
    bool checkInViewport(const Vec3d& pos) const;

    bool checkInViewport(const Vec3f& pos) const;

    Vec3d viewPortIntersect(const Vec3d& p1, const Vec3d& p2) const;

    bool project(const Vec3d& v, Vec3d& win) const;

    bool project(const Vec3f& v, Vec3f& win) const;

    virtual void project(int n, const Vec3d* in, Vec3f* out);

    virtual void project(int n, const Vec3f* in, Vec3f* out);

    virtual GLSLProjector* getGLSLProjector() 
    {
        // No GLSL projection support by default.
        return NULL;
    }

    bool projectInPlace(Vec3d& vd) const;

    bool projectInPlace(Vec3f& v) const;

    bool projectCheck(const Vec3d& v, Vec3d& win) const;

    bool projectCheck(const Vec3f& v, Vec3f& win) const;

    bool unProject(const Vec3d& win, Vec3d& v) const;
    bool unProject(double x, double y, Vec3d& v) const;

    bool projectLineCheck(const Vec3d& v1, Vec3d& win1, const Vec3d& v2, Vec3d& win2) const;

    ModelViewTranformP getModelViewTransform() const;

    Mat4f getProjectionMatrix() const
    {
        // Moved to header for inlining.
        return Mat4f(2.f/viewportXywh[2], 0, 0, 0,
                     0, 2.f/viewportXywh[3], 0, 0, 
                     0, 0, -1., 0.,
                     -(2.f*viewportXywh[0] + viewportXywh[2])/viewportXywh[2], -(2.f*viewportXywh[1] + viewportXywh[3])/viewportXywh[3], 0, 1);
    }


    static const QString maskTypeToString(StelProjectorMaskType type);
    static StelProjectorMaskType stringToMaskType(const QString &s);

    StelProjectorMaskType getMaskType(void) const;

    Vec4i getViewportXywh() const 
    {
        return viewportXywh;
    }

    bool useGravityLabels() const 
    {
        return gravityLabels;
    }

    float getDefaultAngleForGravityText() const
    {
        return defautAngleForGravityText;
    }

    Vec2f getViewportCenterAbsolute() const 
    {
        return viewportCenter;
    }

    float getViewportFovDiameter() 
    {
        return viewportFovDiameter;
    }

protected:
    StelProjector(ModelViewTranformP amodelViewTransform) 
        : modelViewTransform(amodelViewTransform)
        , disableShaderProjection(false)
    {;}

    virtual bool hasDiscontinuity() const =0;
    virtual bool intersectViewportDiscontinuityInternal(const Vec3d& p1, const Vec3d& p2) const = 0;

    virtual bool intersectViewportDiscontinuityInternal(const Vec3d& capN, double capD) const = 0;

    virtual void computeBoundingCap();

    ModelViewTranformP modelViewTransform;  // Operator to apply (if not NULL) before the modelview projection step

    float flipHorz,flipVert;            // Whether to flip in horizontal or vertical directions
    float pixelPerRad;                  // pixel per rad at the center of the viewport disk
    StelProjectorMaskType maskType;     // The current projector mask
    float zNear, oneOverZNearMinusZFar; // Near and far clipping planes
    Vec4i viewportXywh;                 // Viewport parameters
    Vec2f viewportCenter;               // Viewport center in screen pixel
    float viewportFovDiameter;          // diameter of the FOV disk in pixel
    bool gravityLabels;                 // should label text align with the horizon?
    float defautAngleForGravityText;    // a rotation angle to apply to gravity text (only if gravityLabels is set to false)
    SphericalCap boundingCap;           // Bounding cap of the whole viewport

    bool disableShaderProjection;

private:
    void init(const StelProjectorParams& param);
};

#endif // _STELPROJECTOR_HPP_