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"

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);
        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;

    private:
        Mat4d transfoMat;
        Mat4f transfoMatf;
    };

    enum StelProjectorMaskType
    {
        MaskNone,   
        MaskDisk    
    };

    struct StelProjectorParams
    {
        StelProjectorParams()
            : viewportXywh(0, 0, 256, 256)
            , fov(60.f)
            , gravityLabels(false)
            , defaultAngleForGravityText(0.f)
            , maskType(MaskNone)
            , zNear(0.f)
            , zFar(0.f)
            , viewportCenter(128.f, 128.f)
            , viewportCenterOffset(0.f, 0.f)
            , viewportFovDiameter(0.f)
            , flipHorz(false)
            , flipVert(false)
            , devicePixelsPerPixel(1.f) {;}

        Vector4<int> viewportXywh;       
        float fov;                       
        bool gravityLabels;              
        float defaultAngleForGravityText;
        StelProjectorMaskType maskType;  
        float zNear, zFar;               
        Vec2f viewportCenter;            
        Vec2f viewportCenterOffset;      
        float viewportFovDiameter;       
        bool flipHorz, flipVert;         
        float devicePixelsPerPixel;      
    };

    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;
    Vec2f getViewportCenterOffset() const;

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

    float getDevicePixelsPerPixel() const {return devicePixelsPerPixel;}
    
    SphericalRegionP getViewportConvexPolygon(float marginX=0., float marginY=0.) const;

    const SphericalCap& getBoundingCap() const;

    float getPixelPerRadAtCenter() const;

    float getFov() const;

    bool needGlFrontFaceCW() const;

    // 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);

    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;

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

    StelProjectorMaskType getMaskType(void) const;

protected:
    StelProjector(ModelViewTranformP amodelViewTransform)
        : modelViewTransform(amodelViewTransform),
          flipHorz(0.f),
          flipVert(0.f),
          pixelPerRad(0.f),
          maskType(MaskNone),
          zNear(0.f),
          oneOverZNearMinusZFar(0.f),
          viewportFovDiameter(0.f),
          gravityLabels(true),
          defaultAngleForGravityText(0.f),
          devicePixelsPerPixel(1.f) {;}

    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
    Vec2f viewportCenterOffset;         // Viewport center's offset in fractions of screen width/height. Usable e.g. in cylindrical projection to move horizon down.
                        // Currently only Y shift is fully implemented, X shift likely not too meaningful.
    float viewportFovDiameter;          // diameter of the FOV disk in pixel
    bool gravityLabels;                 // should label text align with the horizon?
    float defaultAngleForGravityText;   // a rotation angle to apply to gravity text (only if gravityLabels is set to false)
    SphericalCap boundingCap;           // Bounding cap of the whole viewport
    float devicePixelsPerPixel;         // The number of device pixel per "Device Independent Pixels" (value is usually 1, but 2 for mac retina screens)

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

#endif // _STELPROJECTOR_HPP_