aswi2021virtual-surreality-gitlab/deltarobot/element/wall.cpp @ c137512e

#include "wall.hpp"

const float Wall::DEFORM = 0.5f;
const float Wall::SCALING_FRONT = 1.2f;
const float Wall::SCALING_BACK = 0.6f;
const int Wall::FLOOR_SPLIT = 5;
const int Wall::CEILING_SPLIT = 3;
const int Wall::SIDE_SPLIT = 8;
const int Wall::ENLARGE = 6;

Wall::Wall(const TYPE type): Element(Element::WALL)
{
    this->type = type;
}

void Wall::setData(QVector3D minimum, QVector3D maximum, float sphereRadius)
{
    // Odstranit ulozene hodnoty ke "stare" zdi.
    clear();
    
    // Minimalni kvadr rozsirit tak, aby se do mistnosti vesly i sipky (podle
    // polomeru koule).
    sphereRadius *= ENLARGE;
    minimum += QVector3D(-1.0f * sphereRadius, -1.0f * sphereRadius, -1.0f * sphereRadius);
    maximum += QVector3D(sphereRadius, sphereRadius, sphereRadius);
    
    // Urceni poloviny vysledneho rozsahu pro osy X a Y pro predni a zadni stenu.
    float rangeFrontX = abs(maximum.x() - minimum.x()) * SCALING_FRONT / 2.0f;
    float rangeBackX = abs(maximum.x() - minimum.x()) * SCALING_BACK / 2.0f;
    float rangeFrontY = abs(maximum.y() - minimum.y()) * SCALING_FRONT / 2.0f;
    float rangeBackY = abs(maximum.y() - minimum.y()) * SCALING_BACK / 2.0f;
    
    // Urceni souradnic "deformovaneho" kvadru.
    QVector3D F00 = QVector3D(-1.0f * rangeFrontX, -1.0f * rangeFrontY, maximum.z());
    QVector3D F10 = QVector3D(-1.0f * rangeFrontX, rangeFrontY, maximum.z());
    QVector3D F11 = QVector3D(rangeFrontX, rangeFrontY, maximum.z());
    QVector3D F01 = QVector3D(rangeFrontX, -1.0f * rangeFrontY, maximum.z());
    
    QVector3D B00 = QVector3D(-1.0f * rangeBackX, -1.0f * rangeBackY, minimum.z());
    QVector3D B10 = QVector3D(-1.0f * rangeBackX, rangeBackY, minimum.z());
    QVector3D B11 = QVector3D(rangeBackX, rangeBackY, minimum.z());
    QVector3D B01 = QVector3D(rangeBackX, -1.0f * rangeBackY, minimum.z());
    
    // Rozdeleni steny na mensi casti, do kterych bude vykreslovana textura.
    if (type == TYPE::FLOOR)
    {
        // Podlaha
        split(F01, F00, B00, B01, FLOOR_SPLIT);
    }
    else if (type == TYPE::CEILING)
    {
        // Strop
        split(F10, F11, B11, B10, CEILING_SPLIT);
    }
    else
    {
        // Stena vzadu
        split(B00, B10, B11, B01, SIDE_SPLIT, false);
        // Stena nalevo
        split(F00, F10, B10, B00, SIDE_SPLIT);
        // Stena napravo
        split(F11, F01, B01, B11, SIDE_SPLIT);
    }
}

void Wall::split(const QVector3D &a, const QVector3D &b, const QVector3D &c, const QVector3D &d, const int parts, const bool deform)
{
    // Obecny ctyruhelnik. Deformace smerem doprava (pokud je nastavena), tj. od AB do DC.
    //    b
    //         c
    //
    //  a        d
    
    // Urceni bocnich vektoru (zdola nahoru), ktere definuji vysku jednoho pruhu.
    // Vyska pruhu se deformovat nemusi vubec, je pro kazdy pruh stejna.
    QVector3D leftUp = (b - a) / (float) parts;
    QVector3D rightUp = (c - d) / (float) parts;
    
    for (int y = 0; y < parts; y++)
    {
        // Zjisteni souradnic ctyruhelnika predstavujici jeden pruh.
        QVector3D leftBottom = a + y * leftUp;
        QVector3D leftTop = a + (y + 1) * leftUp;
        QVector3D rightBottom = d + y * rightUp;
        QVector3D rightTop = d + (y + 1) * rightUp;
        
        // Urceni horniho a dolniho vektoru (zleva doprava), ktere definuji sirku
        // jednoho sloupce (dany sloupec ma ve vsech pruzich stejnou sirku).
        // Pokud je nastavena deformace, bude se tykat prave sirek sloupcu, viz dale.
        QVector3D topRight = (rightTop - leftTop) / (float) parts;
        QVector3D bottomRight = (rightBottom - leftBottom) / (float) parts;
        
        QVector3D topRightFirst, topRightDiff, bottomRightFirst, bottomRightDiff, topRightAct, bottomRightAct, topOneOnRightAct, bottomOneOnRightAct;
        if (deform)
        {
            // Jestlize ma dochazet k deformaci, vypocitani sirky prvniho sloupce
            // a rozdilu sirek mezi dvema sloupci.
            
            // Horni sirka prvniho sloupce (nejvice vlevo).
            topRightFirst = (1.0f + DEFORM) * topRight;
            // O kolik se ma linearne snizovat horni sirka sloupce.
            topRightDiff = (topRightFirst - (1.0f - DEFORM) * topRight) / (float) (parts - 1);
            
            // Dolni sirka prvniho sloupce (nejvice vlevo).
            bottomRightFirst = (1.0f + DEFORM) * bottomRight;
            // O kolik se ma linearne snizovat dolni sirka sloupce.
            bottomRightDiff = (bottomRightFirst - (1.0f - DEFORM) * bottomRight) / (float) (parts - 1);
            
            // Nastaveni souradnic prvniho ctyruhelnika.
            topRightAct = leftTop;
            bottomRightAct = leftBottom;
            topOneOnRightAct = topRightAct + topRightFirst;
            bottomOneOnRightAct = bottomRightAct + bottomRightFirst;
        }
        
        for (int x = 0; x < parts; x++)
        {
            if (!deform)
            {
                // Pokud nema dojit k deformaci - rovnomerne rozdeleni.
                bottomRightAct = leftBottom + x * bottomRight;
                bottomOneOnRightAct = leftBottom + (x + 1) * bottomRight;
                topRightAct = leftTop + x * topRight;
                topOneOnRightAct = leftTop + (x + 1) * topRight;
            }
            
            // Ulozit ctyruhelnik.
            addTetragon(bottomRightAct, topRightAct, topOneOnRightAct, bottomOneOnRightAct);
            
            if (deform)
            {
                // Pokud dochazi k deformaci, snizit sirku sloupce, presunout se
                // na zacatek dalsiho a urcit jeho prave souradnice.
                
                topRightAct = topOneOnRightAct;
                bottomRightAct = bottomOneOnRightAct;
                
                topRightFirst -= topRightDiff;
                bottomRightFirst -= bottomRightDiff;
                
                topOneOnRightAct += topRightFirst;
                bottomOneOnRightAct += bottomRightFirst;
            }
        }
    }
}

void Wall::addTetragon(const QVector3D &a, const QVector3D &b, const QVector3D &c, const QVector3D &d)
{
    // Obecny ctyruhelnik - mapovani na souradnice textury (souradnice UV).
    //    b [0,1]
    //         c [1,1]
    //  a [0,0]    d [1,0]
    
    QVector3D n = normal(a, d, b);
    
    // Pro kazdy vrchol upravovat ukladanou kategorii (typ prvku), ktera u "zdi"
    // predstavuje vrchol textury (ctyri vrcholy textury se musi namapovat na
    // vrcholy ctyruhelnika).
    category = Element::WALL + 0;
    addVertex(a, n);
    category = Element::WALL + 2;
    addVertex(d, n);
    category = Element::WALL + 3;
    addVertex(c, n);
    category = Element::WALL + 1;
    addVertex(b, n);
}