4DView.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

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, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef C4DVIEW_H
#define C4DVIEW_H

#include "ViewImpl.h"
#include "ValuesDialogImpl.h"
#include "Rotation.h"

#include <QTimer>
#include <QGLWidget>


class QPaintEvent;
class QStatusBar;

class C4DView;
class Displayable;
class RealFunction;
class Surface;

class CustomFunction;
class CustomPolarFunction;
class CustomSurface;
class CustomComplexFunction;



class C4DView :
    public QGLWidget,
    public UI::ViewImpl {


    private:

        template<class function> class CustomFunctionSlot {
            public:
                static void createCustomFunction(C4DView *view);
                static void createCustomSurface(C4DView *view);
        };

        class Menu4D;
        class MouseHandler4D;

    Q_OBJECT

    public:
        C4DView(QWidget * = 0);
        virtual ~C4DView();


        virtual void applyTransform(const VecMath::Rotation<4> &R,
                                    const VecMath::Vector<4> &T);

        virtual void animate();

        virtual void setSize(unsigned w, unsigned h);

        virtual void setBackground(const Color &);
        virtual void setColors(bool);
        virtual void setCoordinates(bool);
        virtual void setFog(bool);
        virtual void setHyperfog(bool);
        virtual void setLighting(bool);
        virtual void setShading(bool);
        virtual void setTransparence(bool);

        virtual void drawVertex(const VecMath::Vector< 4 > &x, const VecMath::Vector< 3 > &xscr);
        virtual void drawLine(const VecMath::Vector< 4 > &x0, const VecMath::Vector< 4 > &x1,
                              const VecMath::Vector< 3 > &xscr0, const VecMath::Vector< 3 > &xscr1);
        virtual void drawQuadrangle(const VecMath::Vector< 4 > &x0, const VecMath::Vector< 4 > &x1,
                                    const VecMath::Vector< 4 > &x2, const VecMath::Vector< 4 > &x3,
                                    const VecMath::Vector< 3 > &xscr0, const VecMath::Vector< 3 > &xscr1,
                                    const VecMath::Vector< 3 > &xscr2, const VecMath::Vector< 3 > &xscr3);
        virtual void drawPolygon(const std::vector< VecMath::Vector< 4 > >&x ,
                                 const std::vector< VecMath::Vector< 3 > >&xscr );


        double Benchmark3D(int, double, double, double, bool = true);
        double Benchmark4D(int, double, double, double, bool = true);

    private slots:
        virtual void ApplyChanges(const ParameterMap &);

        void OnAnimationTimer();

    private:
        void Transform(const VecMath::Rotation<4> &R, const VecMath::Vector<4> &T);
        void Transform();

        void Project();

        void PreRedraw();
        void Redraw();

        void RenderScene();

        void InitCross();
        void SetupDepthCue(bool);
        void DrawCoordinates(void);

        void StartAnimation();
        void StopAnimation();
        void RandomAnimation(bool);

        QPixmap makePixmap();
        void writeFrame();

        void checkAnglesForOverflow();
        void UpdateStatus(QString = "");

        void AssignValues(const std::shared_ptr<Displayable> &);

        double Size();

        virtual void mouseMoveEvent(QMouseEvent *);
        virtual void mousePressEvent(QMouseEvent *);
        virtual void mouseReleaseEvent( QMouseEvent *);
        virtual void mouseDoubleClickEvent( QMouseEvent *);
        virtual void paintEvent(QPaintEvent * = 0);
        virtual void resizeEvent( QResizeEvent * );
        virtual void initializeGL(void);
        virtual void resizeGL (int, int);

        void setm_rot(const VecMath::Rotation<3, GLdouble> &_r) {
            _rot = _r;
        }
        const VecMath::Rotation<3, GLdouble> &m_rot() {
            return _rot;
        }
        void addm_rot(const VecMath::Rotation<3, GLdouble> &_dmr) {
            _rot += _dmr;
        }

        void setm_trans(const VecMath::Vector<3, GLdouble> &_t) {
            _trans = _t;
        }
        const VecMath::Vector<3, GLdouble> &m_trans() {
            return _trans;
        }
        void addm_trans(const VecMath::Vector<3, GLdouble> &_dmt) {
            _trans += _dmt;
        }

        void setanimationFrame(unsigned b) { _animationFrame = b; }
        unsigned animationFrame() const { return _animationFrame; }
        void setanimationMaxFrames(unsigned b) { _animationMaxFrames = b; }
        unsigned animationMaxFrames() const { return _animationMaxFrames; }
        unsigned animation_fps() const { return _animation_fps; }

        void setObjectList(GLint b) { _objectList = b; }
        GLint ObjectList() const { return _objectList; }
        void setCoordinateCross(GLint b) { _coordinateCross = b; }
        GLint CoordinateCross() const { return _coordinateCross; }

        void setAnimated(bool b) { _animated = b; }
        bool Animated() const { return _animated; }
        void setCurrentlyRendering(bool b) { _currentlyRendering = b; }
        bool CurrentlyRendering() const { return _currentlyRendering; }

        void setAnimationTimer(QTimer * b) { _animationTimer = b; }
        QTimer * AnimationTimer() const { return _animationTimer; }
        void setAnimateRandomTimer(QTimer * b) { _animateRandomTimer = b; }
        QTimer * AnimateRandomTimer() const { return _animateRandomTimer; }

        void setValues(UI::Dialogs::ValuesDialogImpl * b) { _values = b; }
        UI::Dialogs::ValuesDialogImpl * Values() const { return _values; }

        void setMenu(Menu4D *b) { _menu = b; }
        Menu4D *Menu() const { return _menu; }
        void setMouseHandler(MouseHandler4D *m) { _mouseHandler = m; }
        MouseHandler4D *MouseHandler() const { return _mouseHandler; }

    private:
        void SetupDepthCue (float, float);
        void InitLight (void);
        void InitShade (void);
        void InitFog  (void);
        void InitTransparence (void);

    private:                                    //  member variables

        VecMath::Rotation<3, GLdouble> _rot;
        VecMath::Vector<3, GLdouble> _trans;

        unsigned _animationFrame;       
        unsigned _animationMaxFrames;   
        const unsigned _animation_fps;  

        bool _animated;             

        bool _currentlyRendering;   

        GLint _objectList;      
        GLint _coordinateCross; 

        QTimer *_animationTimer;
        QTimer *_animateRandomTimer;

        UI::Dialogs::ValuesDialogImpl *_values;

        Menu4D *_menu;                  
        MouseHandler4D *_mouseHandler;  

        std::vector<std::vector<VecMath::Vector<4> > > _cross;
        std::vector<std::vector<VecMath::Vector<4> > > _crossTrans;
        std::vector<std::vector<VecMath::Vector<3> > > _crossScr;

        static std::string _helpFile;   

    friend class CustomFunctionSlot<CustomFunction>;
    friend class CustomFunctionSlot<CustomPolarFunction>;
    friend class CustomFunctionSlot<CustomComplexFunction>;
    friend class CustomFunctionSlot<CustomSurface>;

    friend class FunctionSlotHelper;
    friend class SurfaceSlotHelper;
    friend class SlotHelper;

};

#endif // !defined(C4DVIEW)