core/StelProjector.hpp

/*
 * Stellarium
 * Copyright (C) 2003 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 _STELPROJECTOR_HPP_
#define _STELPROJECTOR_HPP_

#include "StelProjectorType.hpp"
#include "VecMath.hpp"
#include "StelSphereGeometry.hpp"

class StelProjector
{
public:
    friend class StelPainter;
    friend class StelCore;

    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 Mat4d getApproximateLinearTransfo() const=0;
    };

    class Mat4dTransform: public ModelViewTranform
    {
    public:
        Mat4dTransform(const Mat4d& m) : transfoMat(m),
            transfoMatf(m[0], m[1], m[2], m[3],
                             m[4], m[5], m[6], m[7],
                             m[8], m[9], m[10], m[11],
                             m[12], m[13], m[14], m[15]) {;}

        void forward(Vec3d& v) const {v.transfo4d(transfoMat);}
        void backward(Vec3d& v) const
        {
            // We need no matrix inversion because we always work with orthogonal matrices (where the transposed is the inverse).
            //v.transfo4d(inverseTransfoMat);
            const double x = v[0] - transfoMat.r[12];
            const double y = v[1] - transfoMat.r[13];
            const double z = v[2] - transfoMat.r[14];
            v[0] = transfoMat.r[0]*x + transfoMat.r[1]*y + transfoMat.r[2]*z;
            v[1] = transfoMat.r[4]*x + transfoMat.r[5]*y + transfoMat.r[6]*z;
            v[2] = transfoMat.r[8]*x + transfoMat.r[9]*y + transfoMat.r[10]*z;
        }
        void forward(Vec3f& v) const {v.transfo4d(transfoMatf);}
        void backward(Vec3f& v) const
        {
            // We need no matrix inversion because we always work with orthogonal matrices (where the transposed is the inverse).
            //v.transfo4d(inverseTransfoMat);
            const float x = v[0] - transfoMatf.r[12];
            const float y = v[1] - transfoMatf.r[13];
            const float z = v[2] - transfoMatf.r[14];
            v[0] = transfoMatf.r[0]*x + transfoMatf.r[1]*y + transfoMatf.r[2]*z;
            v[1] = transfoMatf.r[4]*x + transfoMatf.r[5]*y + transfoMatf.r[6]*z;
            v[2] = transfoMatf.r[8]*x + transfoMatf.r[9]*y + transfoMatf.r[10]*z;
        }
        void combine(const Mat4d& m)
        {
            Mat4f mf(m[0], m[1], m[2], m[3],
                             m[4], m[5], m[6], m[7],
                             m[8], m[9], m[10], m[11],
                             m[12], m[13], m[14], m[15]);
            transfoMat=transfoMat*m;
            transfoMatf=transfoMatf*mf;
        }
        Mat4d getApproximateLinearTransfo() const {return transfoMat;}
        ModelViewTranformP clone() const {return ModelViewTranformP(new Mat4dTransform(transfoMat));}

    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
    {
        if (hasDiscontinuity()==false)
            return false;
        Vec3d v1(p1);
        modelViewTransform->forward(v1);
        Vec3d v2(p2);
        modelViewTransform->forward(v2);
        return intersectViewportDiscontinuityInternal(v1, v2);
    }

    bool intersectViewportDiscontinuity(const SphericalCap& cap) const
    {
        if (hasDiscontinuity()==false)
            return false;
        Vec3d v1(cap.n);
        modelViewTransform->forward(v1);
        return intersectViewportDiscontinuityInternal(v1, cap.d);
    }

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

    bool getFlagGravityLabels() const { return gravityLabels; }

    const Vec4i& getViewport() const {return viewportXywh;}

    Vec2f getViewportCenter() const
    {
        return Vec2f(viewportCenter[0]-viewportXywh[0],viewportCenter[1]-viewportXywh[1]);
    }

    int getViewportPosX() const {return viewportXywh[0];}
    int getViewportPosY() const {return viewportXywh[1];}
    int getViewportWidth() const {return viewportXywh[2];}
    int getViewportHeight() const {return viewportXywh[3];}

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

    const SphericalCap& getBoundingCap() const {return boundingCap;}

    float getPixelPerRadAtCenter() const {return pixelPerRad;}

    float getFov() const {return 360.f/M_PI*viewScalingFactorToFov(0.5f*viewportFovDiameter/pixelPerRad);}

    bool needGlFrontFaceCW() const {return (flipHorz*flipVert < 0.f);}

    // Full projection methods
    bool checkInViewport(const Vec3d& pos) const
    {
        return (pos[1]>=viewportXywh[1] && pos[0]>=viewportXywh[0] &&
            pos[1]<=(viewportXywh[1] + viewportXywh[3]) && pos[0]<=(viewportXywh[0] + viewportXywh[2]));
    }

    bool checkInViewport(const Vec3f& pos) const
    {
        return (pos[1]>=viewportXywh[1] && pos[0]>=viewportXywh[0] &&
            pos[1]<=(viewportXywh[1] + viewportXywh[3]) && pos[0]<=(viewportXywh[0] + viewportXywh[2]));
    }

    Vec3d viewPortIntersect(const Vec3d& p1, const Vec3d& p2) const
    {
        Vec3d v1=p1;
        Vec3d v2=p2;
        Vec3d v;
        for (int i=0;i<8;++i)
        {
            v=(v1+v2)*0.5;
            if (!checkInViewport(v))
                v2=v;
            else
                v1=v;
        }
        return v;
    }

    inline bool project(const Vec3d& v, Vec3d& win) const
    {
        win = v;
        return projectInPlace(win);
    }

    inline bool project(const Vec3f& v, Vec3f& win) const
    {
        win = v;
        return projectInPlace(win);
    }

    virtual void project(int n, const Vec3d* in, Vec3f* out)
    {
        Vec3d v;
        for (int i = 0; i < n; ++i, ++out)
        {
            v = in[i];
            modelViewTransform->forward(v);
            out->set(v[0], v[1], v[2]);
            forward(*out);
            out->set(viewportCenter[0] + flipHorz * pixelPerRad * (*out)[0],
                viewportCenter[1] + flipVert * pixelPerRad * (*out)[1],
                ((*out)[2] - zNear) * oneOverZNearMinusZFar);
        }
    }

    virtual void project(int n, const Vec3f* in, Vec3f* out)
    {
        for (int i = 0; i < n; ++i, ++out)
        {
            *out=in[i];
            modelViewTransform->forward(*out);
            forward(*out);
            out->set(viewportCenter[0] + flipHorz * pixelPerRad * (*out)[0],
                viewportCenter[1] + flipVert * pixelPerRad * (*out)[1],
                ((*out)[2] - zNear) * oneOverZNearMinusZFar);
        }
    }

    inline bool projectInPlace(Vec3d& vd) const
    {
        modelViewTransform->forward(vd);
        Vec3f v(vd[0], vd[1], vd[2]);
        const bool rval = forward(v);
        // very important: even when the projected point comes from an
        // invisible region of the sky (rval=false), we must finish
        // reprojecting, so that OpenGl can successfully eliminate
        // polygons by culling.
        vd[0] = viewportCenter[0] + flipHorz * pixelPerRad * v[0];
        vd[1] = viewportCenter[1] + flipVert * pixelPerRad * v[1];
        vd[2] = (v[2] - zNear) * oneOverZNearMinusZFar;
        return rval;
    }

    inline bool projectInPlace(Vec3f& v) const
    {
        modelViewTransform->forward(v);
        const bool rval = forward(v);
        // very important: even when the projected point comes from an
        // invisible region of the sky (rval=false), we must finish
        // reprojecting, so that OpenGl can successfully eliminate
        // polygons by culling.
        v[0] = viewportCenter[0] + flipHorz * pixelPerRad * v[0];
        v[1] = viewportCenter[1] + flipVert * pixelPerRad * v[1];
        v[2] = (v[2] - zNear) * oneOverZNearMinusZFar;
        return rval;
    }

    bool projectCheck(const Vec3d& v, Vec3d& win) const {return (project(v, win) && checkInViewport(win));}

    bool projectCheck(const Vec3f& v, Vec3f& win) const {return (project(v, win) && checkInViewport(win));}

    bool unProject(const Vec3d& win, Vec3d& v) const {return unProject(win[0], win[1], v);}
    bool unProject(double x, double y, Vec3d& v) const;

    bool projectLineCheck(const Vec3d& v1, Vec3d& win1, const Vec3d& v2, Vec3d& win2) const
        {return project(v1, win1) && project(v2, win2) && (checkInViewport(win1) || checkInViewport(win2));}

    ModelViewTranformP getModelViewTransform() const {return modelViewTransform;}

    Mat4f getProjectionMatrix() const {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 {return maskType;}

protected:
    StelProjector(ModelViewTranformP amodelViewTransform) : modelViewTransform(amodelViewTransform) {;}

    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

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

#endif // _STELPROJECTOR_HPP_