ProxyGeometry.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <QtCore\qmath.h>
#include <QtGui\qopenglshaderprogram.h>

namespace PolygonIntersection{
    struct Edge {

        Edge() {};

        Edge(QVector3D* a, QVector3D* b) : a(a), b(b) {};
        QVector3D* a;
        QVector3D* b;
    };

    struct Cube {
        Cube() {};
        Cube(QVector3D sizes) : sizes(sizes){ 
            points.reserve(8);

            // source: http://cococubed.asu.edu/code_pages/raybox.shtml
            // Do not change the order of points!
            points.push_back(QVector3D(sizes.x() / 2.0f, sizes.y() / 2.0f, sizes.z() / 2.0f)); //1
            points.push_back(QVector3D(-sizes.x() / 2.0f, sizes.y() / 2.0f, sizes.z() / 2.0f)); //2
            points.push_back(QVector3D(sizes.x() / 2.0f, -sizes.y() / 2.0f, sizes.z() / 2.0f)); //3
            points.push_back(QVector3D(sizes.x() / 2.0f, sizes.y() / 2.0f, -sizes.z() / 2.0f)); //4
            points.push_back(QVector3D(-sizes.x() / 2.0f, sizes.y() / 2.0f, -sizes.z() / 2.0f)); //5
            points.push_back(QVector3D(-sizes.x() / 2.0f, -sizes.y() / 2.0f, sizes.z() / 2.0f)); //6
            points.push_back(QVector3D(sizes.x() / 2.0f, -sizes.y() / 2.0f, -sizes.z() / 2.0f)); //7
            points.push_back(QVector3D(-sizes.x() / 2.0f, -sizes.y() / 2.0f, -sizes.z() / 2.0f)); //8
            
            origPoints = points;
            edges.reserve(12);

            edges.push_back(Edge(&points[7], &points[4])); //0
            edges.push_back(Edge(&points[4], &points[1])); //1
            edges.push_back(Edge(&points[1], &points[0])); //2

            edges.push_back(Edge(&points[1], &points[5])); //3

            edges.push_back(Edge(&points[7], &points[5])); //4
            edges.push_back(Edge(&points[5], &points[2])); //5
            edges.push_back(Edge(&points[2], &points[0])); //6

            edges.push_back(Edge(&points[6], &points[2])); //7

            edges.push_back(Edge(&points[7], &points[6])); //8
            edges.push_back(Edge(&points[6], &points[3])); //9
            edges.push_back(Edge(&points[3], &points[0])); //10

            edges.push_back(Edge(&points[3], &points[4])); //11

            // only rotation around y-axis
            edgeOrder.resize(8);
            edgeOrder[0] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; // top
            edgeOrder[1] = { 1, 11, 9, 0, 3, 4, 8, 5, 2, 6, 7, 10 }; // top
            edgeOrder[2] = { 7, 8, 0, 9, 6, 10, 11, 2, 5, 3, 1, 4 }; // bottom
            edgeOrder[3] = { 10, 2, 3, 6, 9, 7, 5, 8, 11, 0, 4, 1 }; // top
            edgeOrder[4] = { 11, 10, 6, 9, 0, 8, 7, 4, 1, 3, 5, 2 }; // top
            edgeOrder[5] = { 5, 7, 9, 6, 3, 2, 10, 1, 4, 0, 11, 8 }; // bottom
            edgeOrder[6] = { 7, 6, 2, 5, 8, 4, 3, 0, 9, 11, 1, 10 }; // bottom
            edgeOrder[7] = { 4, 5, 6, 3, 0, 1, 2, 11, 8, 9, 10, 7 }; // bottom
        }

        std::vector<Edge> edges;

        std::vector<QVector3D> points;

        std::vector<QVector3D> origPoints;

        std::vector<std::vector<int>> edgeOrder;

        QVector3D sizes;

        void transform(QMatrix4x4 matrix) {
            for (unsigned int i = 0; i < points.size(); i++) {
                points[i] = matrix * origPoints[i];
            }
        };
    };

    std::vector<QVector3D> calcPolygon(QVector4D normal, Cube& cube, int index);

    bool inside(QVector3D vertex, QVector4D normal);

    bool cross(QVector3D a, QVector3D b, QVector4D normal);

    QVector3D intersect(QVector3D a, QVector3D b, QVector4D normal);

    QVector3D interpolate(QVector3D a, QVector3D b, float t);
};

class ProxyGeometry {
    public:
    ProxyGeometry(QVector3D cubeSize);
    ~ProxyGeometry();

    void updateProxyGeometry(QMatrix4x4 modelMatrix, int samples);

    std::vector < std::vector<QVector3D>>& getPlaneVertices();

    std::vector < std::vector<QVector3D>>& getTexCoords();

    float getSliceDistance();

    private:
    std::vector<std::vector<QVector3D>> planeVertices;

    std::vector<std::vector<QVector3D>> texCoords;

    PolygonIntersection::Cube* cube;

    float sliceDistance;
};