GK/QT/3d-cube-culling/mywindow.h

// Plik naglowkowy klasy MyWindow
// Obiekt tej klasy to glowne okno naszej aplikacji
// Szkielet tego pliku jest tworzony przez QtCreator
// Mozemy do niego dodac deklaracje wlasnych pol i metod

#ifndef MYWINDOW_H
#define MYWINDOW_H

// Dolaczamy plik naglowkowy klasy QMainWindow,
// Klasa QMainWindow posiada swoj wlasny layout.
// latwo mozna do niej dodac pasek menu, widzety dokujace,
// pasek narzedzi i pasek statusu. Na srodku okna
// wyswietlanego przez QMainWindow znajduje sie obszar,
// ktory mozna wypelnic roznymi widgetami.
#include <QMainWindow>

// QPainter to klasa umozliwiajaca niskopoziomowe rysowanie
// na elementach GUI
#include <QPainter>

// QImage to klasa pozwalajaca na niezalezna od sprzetu reprezentacje obrazu.
// Pozwala na bezposredni dostep do poszczegolnych pikseli,
// Bedziemy jej uzywali do tworzenia i przechowywania
// naszych rysunkow
#include <QImage>

// QMouseEvent to klasa obslugujaca zdarzenia zwiazane z myszka
// klikniecia, ruch myszka itp.
#include <QMouseEvent>

#include <math.h>
#include <float.h> // for float,double macros

struct Point{
    float x, y, z;

    Point(float x, float y, float z){
        this->x=x;
        this->y=y;
        this->z=z;
    }

    Point(std::vector<float> vec){
        this->x=vec[0];
        this->y=vec[1];
        this->z=vec[2];
    }

    std::vector<float> GetVector(){
        return std::vector<float>{x, y, z, 1};
    }

    float length(){
        float mag = std::sqrt(std::pow(x, 2) + std::pow(y, 2) + std::pow(z, 2));
        return mag;
    }

    Point Normalize(){
        return *this * (1.0f / this->length());
    }


    Point operator-(const Point& other){
        return Point(this->x - other.x, this->y - other.y, this->z - other.z);
    }

    Point operator*(const float mul){
        return Point(this->x * mul, this->y * mul, this->z * mul);
    }

    Point operator+(const Point& other){
        return Point(this->x + other.x, this->y + other.y, this->z + other.z);
    }
};

enum Mode {Line, Circle, Fill};

namespace Ui {
    class MyWindow;
}


// MyWindow jest podklasa klasy QMainWindow.
class MyWindow : public QMainWindow
{
    // Q_OBJECT jest to makro, ktore musi sie znajdowac
    // we wszystkich klasach definiujacych wlasne sygnaly i sloty
    // W naszej klasie nie jest ono potrzebne,
    // ale QtCreator dodaje je automatycznie do kazdej klasy.
    Q_OBJECT

public:
    // Typowa deklaracja konstruktora w Qt.
    // Parametr "parent" okresla rodzica komponenetu.
    // W przypadku naszej klasy parametr ten wskazuje na null
    // co oznacza, ze komponenet nie ma rodzica, jest to
    // komponenet najwyzszego poziomu
    explicit MyWindow(QWidget *parent = 0);

    // Deklaracja destruktora
    ~MyWindow();

private:
    // QtCreator pozwala na tworzenie GUI za pomoca graficznego kreatora.
    // Skladniki interfejsu i ich wlasciwosci zapisane sa wowczas
    // w pliku XML "nazwa_klasy.ui"
    // Do poszczegolnych elementow GUI odwolujemy sie za pomoca zmiennej "ui"
    Ui::MyWindow *ui;

    Mode mode;

    // Pole przechowujace obrazek
    QImage *img;

    QImage *loaded_img;

    // Pole przechowujace obrazek
    QImage *img_tmp;

    QImage *active_img;

    // Pola przechowujace szerokosc i wysokosc rysunku
    // oraz wspolrzedne jego lewego gornego naroznika
    int szer;
    int wys;
    int poczX;
    int poczY;
    int startX, startY;
    bool draw_finished;
    int segment_count;

    float rotation_angle;
    Point vertices[8] = {
        Point(-1.0f,    1.0f, -1.0f),
        Point(1.0f,     1.0f, -1.0f),
        Point(1.0f,      -1.0f, -1.0f),
        Point(-1.0f,     -1.0f, -1.0f),
        Point(-1.0f,    1.0f,  1.0f),
        Point(1.0f,     1.0f,  1.0f),
        Point(1.0f,      -1.0f,  1.0f),
        Point(-1.0f,     -1.0f,  1.0f),
    };
//    int indices[24] = {
//        0, 1,
//        1, 2,
//        2, 3,
//        3, 0,

//        4, 5,
//        5, 6,
//        6, 7,
//        7, 4,

//        0, 4,
//        1, 5,
//        2, 6,
//        3, 7,
//    };
    int indices[36] = {
        0, 1, 2,
        2, 3, 0,

        6, 5, 4,
        4, 7, 6,

        7, 0, 3,
        0, 7, 4,

        1, 5, 2,
        5, 6, 2,

        3, 2, 6,
        6, 7, 3,

        0, 4, 1,
        1, 4, 5
//        4, 5,
//        5, 6,
//        6, 7,
//        7, 4,

//        0, 4,
//        1, 5,
//        2, 6,
//        3, 7,
    };
    std::vector<float> scale_vec;
    std::vector<float> translation_vec;
    std::vector<float> rotation_vec;
    std::vector<float> sh_vec;

    bool draw_normals;

    int tmp_point_id = 0;
    int tmp_shape_id = 0;

    // Deklaracje funkcji
    void czysc();
    void rysuj1();
    void rysuj2();


    void UpdateTempImage();
    void ApplyTempImage();

    void ClearImage(QImage *img);
    void DrawB(int b);
    void DrawR(int r);
    void DrawG(int g);
    void DrawH(float h);
    void DrawS(float s);
    void DrawV(float v);

    void DrawLine(int x1, int y1, int x2, int y2, QImage *img, QColor color);
    QColor GetPixel(QImage* img, int x, int y);
    void DrawPixel(QImage* img, int x, int y, QColor color);
    QColor GetInterpolatedColor(float x, float y);
    void UpdateImage();
    std::vector<float> GetXY(Point p);

    // Deklaracje slotow, czyli funkcji wywolywanych
    // po wystapieniu zdarzen zwiazanych z GUI
    // np. klikniecie na przycisk, ruch myszka
private slots:
    void on_exitButton_clicked();
    void paintEvent(QPaintEvent*);
    void on_slider_tx_valueChanged(int val);
    void on_slider_ty_valueChanged(int val);
    void on_slider_tz_valueChanged(int val);
    void on_slider_sx_valueChanged(int val);
    void on_slider_sy_valueChanged(int val);
    void on_slider_sz_valueChanged(int val);
    void on_slider_shx_valueChanged(int val);
    void on_slider_shy_valueChanged(int val);
    void on_slider_rx_valueChanged(int val);
    void on_slider_ry_valueChanged(int val);
    void on_slider_rz_valueChanged(int val);
    void on_slider_n_valueChanged(int val);
};

#endif // MYWINDOW_H