opengl_window.cpp

#include "opengl_window.h"
#include "vertex_buffers.h"
#include <QtGui/QSurfaceFormat>

#ifdef _WIN32
#include <windows.h>
#endif

OpenGLWindow::OpenGLWindow()
{
    setTitle("OpenGL ES 2.0, Qt6, C++");
    resize(400, 400);

#ifdef _WIN32
    PostMessage(GetForegroundWindow(), WM_INPUTLANGCHANGEREQUEST, 1, 0x04090409);
#endif

    QSurfaceFormat surfaceFormat;
    surfaceFormat.setDepthBufferSize(24);
    surfaceFormat.setSwapInterval(1);
    connect(this, SIGNAL(frameSwapped()), this, SLOT(update()));
    setFormat(surfaceFormat);

    m_pCollisionConfiguration = new btDefaultCollisionConfiguration();
    m_pDispatcher = new btCollisionDispatcher(m_pCollisionConfiguration);
    m_pOverlappingPairCache = new btDbvtBroadphase();
    m_pSolver = new btSequentialImpulseConstraintSolver();
    m_pWorld = new btDiscreteDynamicsWorld(m_pDispatcher, m_pOverlappingPairCache,
        m_pSolver, m_pCollisionConfiguration);
    m_pWorld->setGravity(btVector3(0, -9.8, 0));
}

OpenGLWindow::~OpenGLWindow()
{
    delete m_pWorld;
    delete m_pSolver;
    delete m_pOverlappingPairCache;
    delete m_pDispatcher;
    delete m_pCollisionConfiguration;
    delete m_pPlayer;
    delete m_pProgram;
    delete m_pPlayerCollider;
    delete m_pGroundCollider;
    delete m_pLightlessProgram;
    delete m_pLightless;
    delete m_pDebugDrawer;
}

void OpenGLWindow::initializeGL()
{
    initializeOpenGLFunctions();

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // qDebug() << "OpenGL version:" << (const char*) glGetString(GL_VERSION) << "\n";
    // qDebug() << "GLSL version: " << (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION) << "\n";
    // qDebug() << "Vendor: " << (const char*) glGetString(GL_VENDOR) << "\n";

    m_pProgram = new QOpenGLShaderProgram();
    m_pProgram->create();
    m_pProgram->addShaderFromSourceFile(QOpenGLShader::ShaderTypeBit::Vertex,
        ":/assets/shaders/texture.vert");
    m_pProgram->addShaderFromSourceFile(QOpenGLShader::ShaderTypeBit::Fragment,
        ":/assets/shaders/texture.frag");
    m_pProgram->link();

    const VertexBuffersData cubeBuffers = VertexBuffers::init(":/assets/models/mario.dae");
    const QVector3D lightPosition(-20.f, 30.f, 35.f);
    m_pPlayer = new Model(m_pProgram, cubeBuffers, ":/assets/models/mario.png",
        lightPosition);

    btBoxShape *groundShape = new btBoxShape(btVector3(3, 0.2f, 3));
    m_pGroundCollider = new Collider(m_pWorld, groundShape, 0);

    btSphereShape *playerShape = new btSphereShape(1);
    m_pPlayerCollider = new Collider(m_pWorld, playerShape, 50.f, btVector3(0.f, 0.5f, 0.f));
    m_pPlayerCollider->pBody->setAngularFactor(btVector3(0.f, 1.f, 0.f));
    m_pPlayerCollider->pBody->setDamping(0.9, 0.99);

    m_pLightlessProgram = new QOpenGLShaderProgram();
    m_pLightlessProgram->create();
    m_pLightlessProgram->addShaderFromSourceFile(QOpenGLShader::ShaderTypeBit::Vertex,
        ":/assets/shaders/lightless.vert");
    m_pLightlessProgram->addShaderFromSourceFile(QOpenGLShader::ShaderTypeBit::Fragment,
        ":/assets/shaders/lightless.frag");
    m_pLightlessProgram->link();

    const VertexBuffersData edgeBuffers = VertexBuffers::init(":/assets/models/cube.dae");
    m_pLightless = new Lightless(m_pLightlessProgram, edgeBuffers);
    m_pDebugDrawer = new DebugDrawer(m_pWorld, m_pLightless);
    m_pDebugDrawer->setDebugMode(btIDebugDraw::DBG_MAX_DEBUG_DRAW_MODE);
    m_pWorld->setDebugDrawer(m_pDebugDrawer);

    m_viewMatrix.lookAt(QVector3D(5.f, 4.f, 6.f), QVector3D(0.f, 0.f, 0.f),
        QVector3D(0.f, 1.f, 0.f));
    m_elapsedTimer.start();
}

void OpenGLWindow::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
    m_projMatrix.setToIdentity();
    m_projMatrix.perspective(50.f, w / (float)h, 0.1f, 500.f);
    m_projViewMatrix = m_projMatrix * m_viewMatrix;
    m_pDebugDrawer->updateProjViewMatrix(m_projViewMatrix);
}

void OpenGLWindow::paintGL()
{
    float deltaTime = m_elapsedTimer.elapsed() / 1000.f;
    m_elapsedTimer.restart();
    keyboardHandler(deltaTime);
    m_pWorld->stepSimulation(deltaTime, 8);

    glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    m_pWorld->debugDrawWorld();
    m_pPlayer->position = m_pPlayerCollider->getPosition();
    m_pPlayer->position.setY(m_pPlayer->position.y() + 0.3f);
    m_pPlayer->rotation = m_pPlayerCollider->getRotation();
    m_pPlayer->draw(m_projViewMatrix);
}

void OpenGLWindow::closeEvent(QCloseEvent *event)
{
    Q_UNUSED(event);
    m_pPlayer->cleanUp();
}

void OpenGLWindow::keyboardHandler(float dt)
{
    if (m_keys[Qt::Key::Key_W] || m_keys[Qt::Key::Key_Up])
    {
        float vy = m_pPlayerCollider->pBody->getLinearVelocity().y();
        btVector3 impulse = btVector3(m_direction.x() * m_linearSpeed * dt, vy,
            m_direction.z() * m_linearSpeed * dt);
        m_pPlayerCollider->pBody->setLinearVelocity(impulse);
    }

    if (m_keys[Qt::Key::Key_S] || m_keys[Qt::Key::Key_Down])
    {
        float vy = m_pPlayerCollider->pBody->getLinearVelocity().y();
        btVector3 impulse = btVector3(-m_direction.x() * m_linearSpeed * dt, vy,
            -m_direction.z() * m_linearSpeed * dt);
        m_pPlayerCollider->pBody->setLinearVelocity(impulse);
    }

    if (m_keys[Qt::Key::Key_A] || m_keys[Qt::Key::Key_Left])
    {
        btVector3 impulse = btVector3(0.f, m_angularSpeed * dt, 0.f);
        m_pPlayerCollider->pBody->setAngularVelocity(impulse);
    }

    if (m_keys[Qt::Key::Key_D] || m_keys[Qt::Key::Key_Right])
    {
        btVector3 impulse = btVector3(0.f, -m_angularSpeed * dt, 0.f);
        m_pPlayerCollider->pBody->setAngularVelocity(impulse);
    }

    m_direction = m_pPlayer->rotation.rotatedVector(m_forward);
}

void OpenGLWindow::keyPressEvent(QKeyEvent *event)
{
    switch (event->key())
    {
        case Qt::Key::Key_W:
        case Qt::Key::Key_Up:
        {
            m_keys[Qt::Key::Key_W] = true;
            m_keys[Qt::Key::Key_Up] = true;
            break;
        }
        case Qt::Key::Key_A:
        case Qt::Key::Key_Left:
        {
            m_keys[Qt::Key::Key_A] = true;
            m_keys[Qt::Key::Key_Left] = true;
            break;
        }
        case Qt::Key::Key_S:
        case Qt::Key::Key_Down:
        {
            m_keys[Qt::Key::Key_S] = true;
            m_keys[Qt::Key::Key_Down] = true;
            break;
        }
        case Qt::Key::Key_D:
        case Qt::Key::Key_Right:
        {
            m_keys[Qt::Key::Key_D] = true;
            m_keys[Qt::Key::Key_Right] = true;
            break;
        }
    }
}

void OpenGLWindow::keyReleaseEvent(QKeyEvent *event)
{
    switch (event->key())
    {
        case Qt::Key::Key_W:
        case Qt::Key::Key_Up:
        {
            m_keys[Qt::Key::Key_W] = false;
            m_keys[Qt::Key::Key_Up] = false;
            break;
        }
        case Qt::Key::Key_A:
        case Qt::Key::Key_Left:
        {
            m_keys[Qt::Key::Key_A] = false;
            m_keys[Qt::Key::Key_Left] = false;
            break;
        }
        case Qt::Key::Key_S:
        case Qt::Key::Key_Down:
        {
            m_keys[Qt::Key::Key_S] = false;
            m_keys[Qt::Key::Key_Down] = false;
            break;
        }
        case Qt::Key::Key_D:
        case Qt::Key::Key_Right:
        {
            m_keys[Qt::Key::Key_D] = false;
            m_keys[Qt::Key::Key_Right] = false;
            break;
        }
    }
}