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

core/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), 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 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) {;}

    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_

---