fluid.h

#ifndef _FLUID_H_
#define _FLUID_H_

#include <sx/SX.h>
#include <sx/SXCore.h>
#include <sx/SXWidget.h>
#include <QSpinBox>
#include <QDoubleSpinBox>
#include <QLabel>
#include <QSlider>
#include <QDialog>
#include <QWidget>
#include <QMainWindow>
#include <QComboBox>
#include <QString>
#include <QLayout>
#include <QSize>
#include <list>
#include <string>
using namespace std;
using namespace sx;

namespace fluid {

    enum GlyphState {
        STATE_ALIVE,
        STATE_DEAD,
        STATE_READY
    };

    class Glyph {
    private:
        static float maxStateSwitchTime;
        static float maxRespawnDistance;
        static float maxKillDistance;

        int id;

        GlyphState state;
        float stateswitchtime;
        UniformFloat *visibility;
        Vector slowdownpos;
        float recordslowdownpos;
        float slowdowntime;

        float vorticity;

        unsigned int groupsize;
        UniformVector *positions[13];
        UniformVector *velocities[13];
        Vector *oldpositions[13];
        Vector *oldvelocities[13];
        UniformFloat *glyphsize;

        Glyph(const Glyph &);
        Glyph &operator = (const Glyph &);

    public:

        static void setMaxStateSwitchTime(float t);
        static void setMaxRespawnDistance(float d);
        static void setMaxKillDistance(float d);

        Glyph(unsigned int id);
        ~Glyph();
        unsigned int getID() const;

        void reset(const Vector &startpos, float *data);
        const Vector &getMidpoint();
        void updatePositions(const float *data);
        void updateVelocities(const float *data);
        void updateGlyphsize();

        unsigned int getGroupSize() const;
        Vector &operator[](unsigned int i);

        float getVorticity() const;

        float length() const;

        float killDistance() const;
        float respawnDistance() const;

        void setAlive();
        void kill();
        void updateStateSwitchTime(float deltatime);
        GlyphState getState() const;
    };

    bool glyphComparison(Glyph *g1, Glyph *g2);

    struct GridElement {
        Glyph *glyph;
        Vector position;
        float length;
        unsigned int x;
        unsigned int y;
    };

    class StreamletGrid {
    private:
        unsigned int cells_x;
        unsigned int cells_y;

        list<GridElement *> elements;
        list<GridElement *> **grid;

        StreamletGrid(const StreamletGrid &);
        StreamletGrid &operator = (const StreamletGrid &);
    public:
        StreamletGrid(unsigned int cells_x, unsigned int cells_y);
        ~StreamletGrid();
        void put(Glyph *glyph);
        void clear();
        void collide();
        bool respawnCollide(Glyph *g);
    };

    enum ViewOption {
        VIEW_STANDARD,
        VIEW_VORTICITY
    };

    class FluidListener: public SXRenderListener {
    public:
        static unsigned int GROUPS;
        static const unsigned int RESPAWN_WIDTH;
        static const unsigned int RESPAWN_HEIGHT;
    private:
        bool pressed;
        Vector mousepos;

        ViewOption view;

        float stopDrawTime;
        float drawTime;
        UniformVector *drawOrigin;

        bool updateGlyphCount;

        list<Glyph *> glyphs;
        list<Glyph *> alive;
        list<Glyph *> dead;
        list<Glyph *> ready;
        unsigned int respawn_pos_x;
        unsigned int respawn_pos_y;

        StreamletGrid *grid;

        Vector getMinRespawnPos();
        Vector getRespawnArea();

        FluidListener(const FluidListener &);
        FluidListener &operator = (const FluidListener &);
    public:
        static ShadeX shadeX;

        void setMaxGlyphs(unsigned int glyphs);
        void setView(ViewOption view);

        void setSolidMap(const string &path);
        void setBackgroundMap(const string &path);

        FluidListener();
        ~FluidListener();
        void create(SXRenderArea &area);
        void reshape(SXRenderArea &area);
        void render(SXRenderArea &area);
        void stop(SXRenderArea &area);
    };

    class FloatSlider: public QWidget {

        Q_OBJECT

    signals:
        void valueChanged(double);
    private slots:
        void updateSlider();
        void updateText();
    private:
        QSlider *slider;
        QDoubleSpinBox *text;

        FloatSlider(const FloatSlider &);
        FloatSlider &operator = (const FloatSlider &);
    public:
        FloatSlider(const string &label, double value, double minVal, double maxVal, QWidget *parent = 0, Qt::WindowFlags f = 0);
        ~FloatSlider();

        void setValue(double value);
        double getValue() const;
        void setMinimum(double minVal);
        double getMinimum() const;
        void setMaximum(double maxVal);
        double getMaximum() const;
        void setRange(double minVal, double maxVal);
    };

    class IntSlider: public QWidget {

        Q_OBJECT

    signals:
        void valueChanged(int);
    private slots:
        void updateSlider();
        void updateText();
    private:
        QSlider *slider;
        QSpinBox *text;

        IntSlider(const IntSlider &);
        IntSlider &operator = (const IntSlider &);
    public:
        IntSlider(const string &label, int value, int minVal, int maxVal, QWidget *parent = 0, Qt::WindowFlags f = 0);
        ~IntSlider();

        void setValue(int value);
        int getValue() const;
        void setMinimum(int minVal);
        int getMinimum() const;
        void setMaximum(int maxVal);
        int getMaximum() const;
        void setRange(int minVal, int maxVal);
    };

    class WarningWidget: public QDialog {
        Q_OBJECT
    private:
        WarningWidget(const WarningWidget &);
        WarningWidget &operator = (const WarningWidget &);
    public:
        WarningWidget(const QString &title, const QString &text, QWidget *w);
    };

    class FluidLayout: public QWidget {

        Q_OBJECT

    private:

        FluidLayout(const FluidLayout &);
        FluidLayout &operator = (const FluidLayout &);

    public:
        
        FluidLayout();
        QSize sizeHint() const;
        bool hasHeightForWidth () const;
        int heightForWidth(int w) const;
//      bool hasHeightForWidth();
//      int heightForWidth(int w) const;

    };

    class MainWidget: public QMainWindow {
        
        Q_OBJECT

    private:
        FluidListener *fluidListener;

        IntSlider *maxGlyphs;
        FloatSlider *maxStateSwitchTime;
        FloatSlider *maxRespawnDistance;
        FloatSlider *maxKillDistance;
        QComboBox *viewOptions;

        MainWidget(const MainWidget &);
        MainWidget &operator = (const MainWidget &);
    public slots:

        void updateMaxGlyphs();
        void updateMaxStateSwitchTime();
        void updateMaxRespawnDistance();
        void updateMaxKillDistance();
        void updateViewOptions();
        void loadSolid();
        void loadBackground();
        void showInfo();

    public:
        static const string VIEWOPTION_STANDARD;
        static const string VIEWOPTION_VORTICITY;

        MainWidget();
        ~MainWidget();
    };

}

#endif