aswi2021virtual-surreality-gitlab/deltarobot/gl/scene.cpp @ f06d5ae1

#include "scene.hpp"

#include "../curvedataserver.h"

const int Scene::TRAJECTORY_I = 0;
const int Scene::SPHERE_I = 1;
const int Scene::SPHERE_II = 2;
const int Scene::FIRST_ARROW_I = 3;
const float Scene::FIRST_ARROW_WIDTH_SCALING = 750.0f;
const float Scene::SECOND_ARROW_WIDTH_SCALING = 400.0f;
const QVector3D Scene::MODIFY_LIGHT_POSITION = QVector3D(0, 0, 0);
const int Scene::ROTATE_REDUCTION = 25;

Scene::Scene(QWidget *parent): QOpenGLWidget(parent)
{
    xAngle = 0;
    yAngle = 0;
    eyeAngle = 45;
    shaderProgram = NULL;
    
    // Vytvoreni grafickych prvku.
    elements[TRAJECTORY_I] = (Element *) new Trajectory();
    elements[SPHERE_I] = (Element *) new Sphere(true);
    elements[SPHERE_II] = (Element *) new Sphere(false);
    elements[FIRST_ARROW_I] = (Element *) new Arrow(true);
    elements[FIRST_ARROW_I + 1] = (Element *) new Arrow(false);
    elements[FIRST_TYPE_WALL_I] = (Element *) new Wall(Wall::TYPE::FLOOR);
    elements[FIRST_TYPE_WALL_I + 1] = (Element *) new Wall(Wall::TYPE::CEILING);
    elements[FIRST_TYPE_WALL_I + 2] = (Element *) new Wall(Wall::TYPE::SIDE);
    
    // Cesty k vyuzivanym texturam.
    texturePath[0] = tr(":/img/floor.png");
    texturePath[1] = tr(":/img/ceiling_1013.png");
    texturePath[2] = tr(":/img/tile.png");
    
    // Barva pozadi, zde je zbytecne nastavovat alfa kanal.
    backgroundColor = QVector3D(0.702f, 1, 1);
    // Barva tubusu predstavujici krivku.
    colorValues[0] = QVector4D(1, 0.737f, 0.231f, 0.7f);
    // Barva koule, která se pohybuje.
    colorValues[1] = QVector4D(0, 0.4f, 1, 0.7f);
    //Barva statické koule
    colorValues[2] = QVector4D(0, 0.8f, 0.4f, 0.0f);
    // Barva prvni (dulezitejsi) krivky.
    colorValues[3] = QVector4D(0, 1, 0, 1);
    // Barva druhe (mene dulezite) krivky. Zmena pruhlednosti = zmena alfa kanalu.
    colorValues[4] = QVector4D(1, 0, 0, 0.75f);
}

Scene::~Scene()
{
    clear();
    // Uvolnit zbyvajici alokovanou pamet (uz zbyvaji pouze graficke prvky, ktere
    // jsou vytvoreny na zacatku a vyuzivany po celou dobu behu programu - nejsou
    // nejak napojeny na jadro OpenGL, hodnoty v techto objektech se vzdy
    // prekopiruji do celkoveho pole, ktere se pak ulozi do bufferu).
    for (int i = 0; i < FIRST_TYPE_WALL_I + 3; i++)
    {
        delete elements[i];
    }
}

void Scene::setCurve(QList<QVector4D> curve, CurveDataServer * cdServer)
{
    // Vyhledani minimalnich a maximalnich souradnic.
    QList<QVector3D> curve3d;
    QVector3D minimum = curve.at(0).toVector3D();
    QVector3D maximum = curve.at(0).toVector3D();
    int itemCount = curve.size();
#if 0
    for (int i = 1; i < curve.count(); i++)
    {
        if (curve.at(i).x() < minimum.x())
        {
            minimum.setX(curve.at(i).x());
        }
        else if (curve.at(i).x() > maximum.x())
        {
            maximum.setX(curve.at(i).x());
        }
        if (curve.at(i).y() < minimum.y())
        {
            minimum.setY(curve.at(i).y());
        }
        else if (curve.at(i).y() > maximum.y())
        {
            maximum.setY(curve.at(i).y());
        }
        if (curve.at(i).z() < minimum.z())
        {
            minimum.setZ(curve.at(i).z());
        }
        else if (curve.at(i).z() > maximum.z())
        {
            maximum.setZ(curve.at(i).z());
        }
    }
#else
    //max a min nepocitat podle kriky, ale mit vzdycky maximalni rozsah
    minimum = QVector3D(-3200,-3200,0);
    maximum = QVector3D(3200,3200,9000);
#endif

    // Posunout stred krivky do pocatku soustavy souradnic (kvuli ruznym upravam).
    // Uchovat stred puvodne umistene krivky kvuli prichozim bodum predstavujici
    // pozici koule (souradnice tohoto bodu se take musi upravit pro presne zobrazeni).
    center = Sphere::middlePoint(minimum, maximum);
    minimum -= center;
    maximum -= center;
    curve3d.clear();
    if (itemCount > MAX_CURVE_SIZE)
        itemCount = MAX_CURVE_SIZE;
    for (int i = 0; i < itemCount; i++)
    {
        curve3d.append(curve[i].toVector3D() - center);
    }
    
    // Zjisteni a nastaveni optimalni polohy kamery na ose Z.
    QVector3D marginForTube(Trajectory::MAX_RADIUS, Trajectory::MAX_RADIUS, Trajectory::MAX_RADIUS);
    QVector3D marginForSphere(Sphere::getMaxRadius(), Sphere::getMaxRadius(), Sphere::getMaxRadius());
    float tg = tan((eyeAngle / 2) * M_PI / 180);
    QVector3D heights = QVector3D(maximum + marginForTube + marginForSphere) / tg;
    camera.set(QVector3D(0, 0, maximum.z() + max(heights.x(), heights.y())));
    
    // Nastaveni atributu vykreslovanych objektu.
    ((Trajectory *) (elements[TRAJECTORY_I]))->setNewCurve(curve3d, minimum.z(), maximum.z());
    ((Sphere *) (elements[SPHERE_I]))->setRangeZ(minimum.z(), maximum.z());
#ifdef USE_STATIC_SPHERE
    ((Sphere *) (elements[SPHERE_II]))->setRangeZ(minimum.z(), maximum.z());
#else
    ((Sphere *) (elements[SPHERE_II]))->setRangeZ(0,0);
    ((Sphere *) (elements[SPHERE_II]))->setPosition(QVector3D(0,0,-3200));
#endif
    for (int i = FIRST_TYPE_WALL_I; i < ELEMENT_COUNT; i++)
    {
        ((Wall *) (elements[i]))->setData(minimum, maximum, ((Sphere *) (elements[SPHERE_I]))->getMaxRadius());
    }
    
    // Upravit data v bufferu.
    updateBufferData();
    
    // Prenastavit pozici svetla.
    shaderProgram->bind();
    shaderProgram->setUniformValue(lightLocation, camera.getPosition() + MODIFY_LIGHT_POSITION);
    int colorLocation = shaderProgram->uniformLocation("un_Color[0]");
    shaderProgram->setUniformValue(colorLocation, colorValues[0]);
    shaderProgram->release();
    
    // Vynulovat pripadnou rotaci.
    setXAngle(0); setYAngle(0);
    
    // Vykreslit.
    update();

    if (cdServer) {
        cdServer->sendNewCurve(curve3d);
    }
}

void Scene::setSphereData(const QVector3D &position, const QVector3D &fArrow, const QVector3D &sArrow)
{
    // Zmenit vektory pro prvni a druhou sipku.
    firstArrow = fArrow;
    secondArrow = sArrow;
    // Zmenit pozici koule.
    ((Sphere *) (elements[SPHERE_I]))->setPosition(position - center);
    // Prekreslit scenu.
    update();
}

void Scene::setTestSphereData(const QVector3D &position)
{
#ifdef USE_STATIC_SPHERE
    // Zmenit pozici koule.
    ((Sphere *) (elements[SPHERE_II]))->setPosition(position - center);
    // Prekreslit scenu.
    update();
#endif
}

QVector3D Scene::getArrow(bool first)
{
    return first ? firstArrow : secondArrow;
}

void Scene::setArrow(bool first, QVector3D vector)
{
    first ? firstArrow = vector : secondArrow = vector;
}

void Scene::setTubusColor(QVector4D color)
{
    colorValues[0] = color;
}

void Scene::addSphereData(QVector3D position, const bool start, const bool finish)
{
    QVector3D minimum = QVector3D(-3200,-3200,0);
    QVector3D maximum = QVector3D(3200,3200,9000);

    // Posunout stred krivky do pocatku soustavy souradnic (kvuli ruznym upravam).
    // Uchovat stred puvodne umistene krivky kvuli prichozim bodum predstavujici
    // pozici koule (souradnice tohoto bodu se take musi upravit pro presne zobrazeni).
    center = Sphere::middlePoint(minimum, maximum);
    minimum -= center;
    maximum -= center;
    //position -= center;

    if (start) {
        // Zjisteni a nastaveni optimalni polohy kamery na ose Z.
        QVector3D marginForTube(Trajectory::MAX_RADIUS, Trajectory::MAX_RADIUS, Trajectory::MAX_RADIUS);
        QVector3D marginForSphere(Sphere::getMaxRadius(), Sphere::getMaxRadius(), Sphere::getMaxRadius());
        float tg = tan((eyeAngle / 2) * M_PI / 180);
        QVector3D heights = QVector3D(maximum + marginForTube + marginForSphere) / tg;
        camera.set(QVector3D(0, 0, maximum.z() + max(heights.x(), heights.y())));

        // Nastaveni atributu vykreslovanych objektu.
    }
    ((Trajectory *) (elements[TRAJECTORY_I]))->addNewPointToCurve(position, start, finish);
    if (start) {
        ((Sphere *) (elements[SPHERE_I]))->setRangeZ(minimum.z(), maximum.z());
        ((Sphere *) (elements[SPHERE_II]))->setRangeZ(minimum.z(), maximum.z());
        for (int i = FIRST_TYPE_WALL_I; i < ELEMENT_COUNT; i++)
        {
            ((Wall *) (elements[i]))->setData(minimum, maximum, ((Sphere *) (elements[SPHERE_I]))->getMaxRadius());
        }
    }

    // Upravit data v bufferu.
    updateBufferData();

    // Prenastavit pozici svetla.
    shaderProgram->bind();
    shaderProgram->setUniformValue(lightLocation, camera.getPosition() + MODIFY_LIGHT_POSITION);
    int colorLocation = shaderProgram->uniformLocation("un_Color[0]");
    shaderProgram->setUniformValue(colorLocation, colorValues[0]);
    shaderProgram->release();

    // Vynulovat pripadnou rotaci.
    setXAngle(0); setYAngle(0);

    // Vykreslit.
    update();
}

QSize Scene::minimumSizeHint() const
{
    return QSize(100, 100);
}

QSize Scene::sizeHint() const
{
    return QSize(500, 500);
}

void Scene::initializeGL()
{
    // V prubehu chodu aplikace muze dojit ke zruseni sceny a k jejimu opetovnemu
    // vytvoreni (opetovnemu zavolani initializeGL()). Proto je vhodne po sobe
    // uklidit v pripade teto nastale udalosti.
    QObject::connect(context(), SIGNAL(aboutToBeDestroyed()), this, SLOT(clear()));
    
    // Vytvoreni GLSL podprogramu. Pridani zdrojovych souboru a napojeni attribute
    // promennych na hodnoty, ktere budou vyuzivany pri mapovani hodnot.
    shaderProgram = new QOpenGLShaderProgram();
    shaderProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/glsl/shader.vert");
    shaderProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/glsl/shader.frag");
    shaderProgram->bindAttributeLocation("vertex", 0);
    shaderProgram->bindAttributeLocation("normal", 1);
    shaderProgram->bindAttributeLocation("group", 2);
    shaderProgram->link();
    
    shaderProgram->bind();
    
    // Vytvoreni textur a pocatecni inicializace uniform atributu TEXTURE.
    for (int i = 0; i < TEXTURE_COUNT; i++)
    {
        textures[i] = new QOpenGLTexture(QImage(texturePath[i]).mirrored());
    }
    shaderProgram->setUniformValue("texture", 0);
    
    // Zjisteni lokaci ostatnich uniform atributu.
    projectionLocation = shaderProgram->uniformLocation("un_Projection");
    lightLocation = shaderProgram->uniformLocation("un_Light");
    for (int i = 0; i < FIRST_TYPE_WALL_I; i++)
    {
        normalLocations[i] = shaderProgram->uniformLocation(QString("un_Normal[%1]").arg(i));
        mvLocations[i] = shaderProgram->uniformLocation(QString("un_ModelView[%1]").arg(i));
        
        // U barev rovnou nastavit i obsah promennych.
        int colorLocation = shaderProgram->uniformLocation(QString("un_Color[%1]").arg(i));
        shaderProgram->setUniformValue(colorLocation, colorValues[i]);
    }
    
    // Pocatecni inicializace pozice svetla a spusteni shader programu.
    shaderProgram->setUniformValue(lightLocation, QVector3D(0, 0, 0));
    shaderProgram->release();
    
    // Pro jistotu, manualni vytvoreni pole pro vrcholy a spojeni se scenou.
    vao.create();
    QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
    
    // Vytvoreni buffer pro vrcholy.
    buffer.create();
    buffer.bind();
    
    // Namapovani hodnot z bufferu na attribute promenne v shaderu.
    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
    f->glEnableVertexAttribArray(0);
    f->glEnableVertexAttribArray(1);
    f->glEnableVertexAttribArray(2);
    f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, Element::DATA_COUNT_FOR_VERTEX * sizeof(GLfloat), reinterpret_cast<void *>(0 * sizeof(GLfloat)));
    f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, Element::DATA_COUNT_FOR_VERTEX * sizeof(GLfloat), reinterpret_cast<void *>(3 * sizeof(GLfloat)));
    f->glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, Element::DATA_COUNT_FOR_VERTEX * sizeof(GLfloat), reinterpret_cast<void *>(6 * sizeof(GLfloat)));
    buffer.release();
    
    // Nastaveni vykreslovacich modu.
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glEnable(GL_MULTISAMPLE); // Anti-aliasing (s QSurfaceFormat::setSamples(4)).
    glEnable(GL_BLEND); // Pruhlednost.
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void Scene::paintGL()
{
    QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
    shaderProgram->bind();
    
    // Nastaveni zmenenych globalnich promennych shaderum.
    shaderProgram->setUniformValue(projectionLocation, projection);
    for (int i = 0; i < FIRST_TYPE_WALL_I; i++)
    {
        shaderProgram->setUniformValue(normalLocations[i], worlds[i].normalMatrix());
        shaderProgram->setUniformValue(mvLocations[i], camera * worlds[i]);

        // U vsech vykreslovanych prvku nastavit globalni rotaci.
        worlds[i].setToIdentity();
        worlds[i].rotate(xAngle / (float) ROTATE_REDUCTION, QVector3D(1, 0, 0));
        worlds[i].rotate(yAngle / (float) ROTATE_REDUCTION, QVector3D(0, 1, 0));
        
        if (i > TRAJECTORY_I)
        {
            float sphereScaling;
            if (i == SPHERE_II) {
                worlds[i].translate(((Sphere *) (elements[SPHERE_II]))->getPosition());
                sphereScaling = ((Sphere *) elements[SPHERE_II])->getCurrentScaling();
            } else {
                // Jak pro kouli, tak pro sipky, provest posunuti do nastaveneho bodu.
                worlds[i].translate(((Sphere *) (elements[SPHERE_I]))->getPosition());
                sphereScaling = ((Sphere *) elements[SPHERE_I])->getCurrentScaling();
            }
            
            if (i == SPHERE_I)
            {
                // Pro kouli provest danou zmenu meritka.
                worlds[i].scale(sphereScaling);
            } else if (i == SPHERE_II) {
                worlds[i].scale(sphereScaling);
            } else {
                QVector3D top = QVector3D(0, 1, 0);
                
                QVector3D arrow;
                float arrowScaling;
                if (i == FIRST_ARROW_I)
                {
                    arrow = firstArrow;
                    arrowScaling = FIRST_ARROW_WIDTH_SCALING;
                }
                else
                {
                    arrow = secondArrow;
                    arrowScaling = SECOND_ARROW_WIDTH_SCALING;
                }
                
                // Pro obe sipky urcit, podle jakeho vektoru ma byt provedena
                // rotace, o jaky uhel maji byt orotovany a podle velikosti
                // vektoru nastavit i zmenu meritka.
                float angle = acos(QVector3D::dotProduct(arrow, top) / (arrow.length() * top.length())) * 180 / M_PI;
                QVector3D normal = QVector3D::crossProduct(top, arrow);
                worlds[i].rotate(angle, normal);
                worlds[i].scale(sphereScaling * arrowScaling, sphereScaling * arrow.length(), sphereScaling * arrowScaling);
            }
        }
    }
    
    // Nastavit kam ma byt provedeno vykreslovani a vycistit 3D scenu.
    glViewport(0, 0, width(), height());
    glClearColor(backgroundColor.x(), backgroundColor.y(), backgroundColor.z(), 1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    if (((Trajectory *) elements[TRAJECTORY_I])->isSet())
    {
        // Pomocna promenna pro urceni pocatecnich indexu vykreslovacich komponent.
        int vertCount = 0;

        // Vykresleni vsech grafickych prvku az na zdi.
        int i;
        int auxVertexCount = 0;
        bool sphereIsSet = ((Sphere *) elements[SPHERE_I])->isSet();
        //bool staticSphereIsSet = ((Sphere *) elements[SPHERE_II])->isSet();
        for (i = 0; i < FIRST_TYPE_WALL_I; i++)
        {
            vertCount += elements[i]->vertexCount();
            if (!sphereIsSet && i > 0)
            {
                auxVertexCount += elements[i]->vertexCount();
            }
        }
        // Pokud neni nastavena pozice pro kouli a sipky, vykreslit pouze trajektorii.
        glDrawArrays(GL_TRIANGLES, 0, vertCount - auxVertexCount);

        // Vykresleni zdi, stropu a podlah.
        for (int j = 0; j < TEXTURE_COUNT; j++, i++)
        {
            textures[j]->bind();
            glDrawArrays(GL_QUADS, vertCount, elements[i]->vertexCount());
            vertCount += elements[i]->vertexCount();
        }
    }

    shaderProgram->release();
    buffer.release();
}

void Scene::resizeGL(int w, int h)
{
    // Nastavit matici projekce pri kazde zmene velikosti okna.
    projection.setToIdentity();
    projection.perspective(eyeAngle, w / (float) h, 1, 40000);
}

void Scene::mousePressEvent(QMouseEvent *event)
{
    // Pri kazdem stisknuti tlacitka ulozit, kde je kurzor (kvuli otaceni).
    lastPosition = event->pos();
}

void Scene::mouseMoveEvent(QMouseEvent *event)
{
    if (event->buttons() == Qt::LeftButton || event->buttons() == Qt::RightButton)
    {
        // Pro obe tlacitka otacet stejne, konkretne podle osy X a Y.
        int dx = event->x() - lastPosition.x();
        int dy = event->y() - lastPosition.y();
        lastPosition = event->pos();
        setXAngle(xAngle + 5 * dy);
        setYAngle(yAngle + 5 * dx);
        update();
    }
}

void Scene::wheelEvent(QWheelEvent *e)
{
    // Pri pohybu kolecka na mysi priblizovat ci oddalovat scenu (resp. kameru
    // k/od pocatku soustavy souradnic).
    if (e != NULL)
    {
        if (e->delta() > 0)
        {
            camera.zoomOut();
        }
        else
        {
            camera.zoomIn();
        }
    }
}

void Scene::updateBufferData()
{
    int resultDataCount = 0;
    for (int i = 0; i < ELEMENT_COUNT; i++)
    {
        resultDataCount += elements[i]->dataCount();
    }
    
    // Vytvoreni pole s hodnotami pro vsechny vykreslovane prvky.
    GLfloat *resultData = new GLfloat[resultDataCount];
    int resultDataIndex = 0;
    for (int i = 0; i < ELEMENT_COUNT; i++)
    {
        const GLfloat *data = elements[i]->getData();
        for (int j = 0; j < elements[i]->dataCount(); j++)
        {
            resultData[resultDataIndex++] = data[j];
        }
    }
    
    // Prenastavit obsah bufferu.
    buffer.bind();
    buffer.allocate(resultData, resultDataCount * sizeof(GLfloat));
    delete[] resultData;
}

void Scene::setXAngle(int angle)
{
    angle %= 360 * ROTATE_REDUCTION;
    
    if (angle != xAngle)
    {
        xAngle = angle;
    }
}

void Scene::setYAngle(int angle)
{
    angle %= 360 * ROTATE_REDUCTION;
    
    if (angle != yAngle)
    {
        yAngle = angle;
    }
}

void Scene::clear()
{
    if (shaderProgram != NULL)
    {
        makeCurrent();
        
        // Zruseni vytvoreneho bufferu pro data pro vrcholy.
        // Uvolneni pameti od alokovaneho pole pro vsechny hodnoty vsech vrcholu
        // viz updateBufferData().
        buffer.destroy();
        
        // Zruseni GLSL podprogramu.
        delete shaderProgram;
        shaderProgram = NULL;
        
        // Vycisteni pameti od alokovanych textur.
        for (int i = 0; i < TEXTURE_COUNT; i++)
        {
            textures[i]->destroy();
            textures[i] = NULL;
        }
        
        doneCurrent();
    }
}