src/editor/Game/mappainter.h

Go to the documentation of this file.

#ifndef MAPPAINTER_H
#define MAPPAINTER_H


// Hint : before to read this file, fold all comments blocks/
// all blocks and unfold the class you want to see. :)


#include "map.h"
#include "GUI/options.h"

#define MINMAX(a,x,b) std::min(std::max(a,x),b)

class RlCoords : public QPointF
{
public:
    RlCoords() : QPointF(0,0){}
    explicit RlCoords(qreal x, qreal y) : QPointF(x,y){}
    explicit RlCoords(const QPointF &p) : QPointF(p){}
};

class ClCoords : public QPointF
{
public:
    ClCoords() : QPointF(0,0){}
    explicit ClCoords(qreal x, qreal y) : QPointF(x,y){}
    explicit ClCoords(const QPointF &p) : QPointF(p){}
};

class PtCoords : public QPointF
{
public:
    PtCoords() : QPointF(0,0){}
    explicit PtCoords(qreal x, qreal y) : QPointF(x,y){}
    explicit PtCoords(const QPointF &p) : QPointF(p){}
};

class PxCoords : public QPointF
{
public:
    PxCoords() : QPointF(0,0){}
    explicit PxCoords(qreal x, qreal y) : QPointF(x,y){}
    explicit PxCoords(const QPointF &p) : QPointF(p){}
    PxCoords(const QPoint &p) : QPointF(p){}
    PxCoords(int x, int y) : QPointF(x,y){}
};



class MapPainter : public QObject
{
    // TODO Mode lecture seule.
    Q_OBJECT
public:
    enum Element{
        Nothing = 0,            
        CellBackground = 1,     
        Grid = 2,               
        CellSelection = 4,      
        CellHighlighting = 8,   
        Objects = 16,           
        All = 31                
    };
    MapPainter(QObject *parent = 0); 
    MapPainter(Map *m, QObject *parent = 0); 
    void setPaintedElement(Element e, bool painted = true); 
    void setPaintedElements(Element e); 
    void setMap(Map* m); 
    void paint(QPainter& p); 
    const QImage& render(); 
    RlCoords viewCenter() const; 
    void setViewCenter(RlCoords relativeCenter); 
    void setViewCenter(double relativeCenterX, double relativeCenterY); 
    void setViewCenterQuiet(double x, double y); 
    double scale() const; 
    void setScale(double scale); 
    void setScaleDomain(double scaleMin, double scaleMax); 
    bool setHighlightedCell(const ClCoords& p); 
    bool setHighlightedCell(int i, int j); 
    QPoint highlightedCell() const; 
    bool hasHighlightedCell() const; 
    bool isCell(const ClCoords &c) const; 
    void resize(QSize s); 
    void resize(int wi, int he); 
    QSize size() const; 
    void zoom(double factor, QPointF fixedPoint); 
    QPair<bool,bool> move(PxCoords delta, QPointF center); 
    QSize virtualSize() const; 
    PxCoords ptToPxl(PtCoords p) const; 
    PtCoords pxlToPt(PxCoords p) const; 
    PtCoords cooToPt(ClCoords p) const; 
    ClCoords ptToCoo(PtCoords p) const; 
    PxCoords cooToPxl(ClCoords p) const; 
    ClCoords pxlToCoo(PxCoords p) const; 
    PtCoords indToPt(int i, int j) const; 
    const QColor &selectedCellColor() const; 
    const QColor &preSelectedCellColor() const; 
    void setSelectedCellColor(const QColor &c); 
    void setPreSelectedCellColor(const QColor &c); 
signals:
    void mapSizeChanged(QSize); 
    void viewCenterChanged(QPoint); 
private slots:
    void updateMap(); 
private:
    inline void globalViewChanged();
    void updateBackground();
    void updateViewParameters();

    inline void changeBackgroundSize();
    inline void changeBackgroundDistortion();
    QImage &getBackground(const CellType *ct);

    Map* map;
    Element displayed;
    QMatrix isometricTransform; // Matrix of the image transformation
    int pWidth, pHeight;
    int nbCellsX, nbCellsY;
    int mapWidth, mapHeight;
    int selCellX, selCellY;
    double angleX, angleY;
    double centerX, centerY;
    double centerVarX, centerVarY;
    double viewScale;
    double ratioFactor;
    QSize cellSize;

    QColor selColor, preSelColor;

    PtCoords *intersec;
    bool changesOccured;
    QDateTime lastMapUpdate;
    QMap<int, QImage> cellBackgrounds; // Contains the distorted images
    QMap<int, QImage> scaledCellBackgrounds;

    QImage im;

    int iMin, iMax, jMin, jMax;


};
inline MapPainter::Element operator|(MapPainter::Element a, MapPainter::Element b){
    return static_cast<MapPainter::Element>(static_cast<int>(a)|static_cast<int>(b));
}
inline MapPainter::Element operator&(MapPainter::Element a, MapPainter::Element b){
    return static_cast<MapPainter::Element>(static_cast<int>(a)&static_cast<int>(b));
}
inline MapPainter::Element operator^(MapPainter::Element a, MapPainter::Element b){
    return static_cast<MapPainter::Element>(static_cast<int>(a)&!static_cast<int>(b));
}
#endif // MAPPAINTER_H