Не отрисовывается OpenGL в программе при запуске из QtCreator'а и на другом компьютере, но отрисовывается при запуске из «Проводника» — Почему?

Question

[Павел Матвеев]

Пытаюсь работать с OpenGL через QOpenGLWidget и QOpenGLFunctions_3_3_core - написал небольшую тестовую программу. При запуске из QtCreator'а и с чужого компьютера выводятся окошко и не закрашенный прямоугольник, и он не "мигает", как должен по программе:

Некорректный результат

При запуске же на моём компьютере из "проводника", программа работает так, как надо - выводится "мигающий"(картинка не gif, так что не видно, но оно так) градиент:

Корректный результат

Ситуация одинакова как для Debug сборки, так и для Release.
Как понимаю, не хватает каких-то .dll файлов, но абсолютно без понятия, каких именно.
Всё, что собрали QtCreator и windeployqt.exe:

Файлы

На всякий случай, загрузил сюда .pro-файл и весь код widget'а, использующего OpenGL.

.pro-файл

QT += core gui opengl
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG += c++17

SOURCES += \
GL/Program.cpp \
GL/VAO.cpp \
main.cpp \
mainwindow.cpp \
menubar.cpp \
oglwidget.cpp \
statusbar.cpp
INCLUDEPATH += \
C:/_LIBS/glm.0.9.9.800/build/native/include
HEADERS += \
GL/Program.h \
GL/VAO.h \
mainwindow.h \
menubar.h \
oglwidget.h \
statusbar.h
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

DISTFILES += \
res/glsl/first.frag \
res/glsl/first.vert

OGLWidget.h

#pragma once
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <glm/glm.hpp>
#include "GL/Program.h"
#include "GL/VAO.h"

class OGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_3_3_Core
{
    Q_OBJECT
protected:
    void initializeGL() override;
    void paintGL() override;
    void resizeGL(int width, int height) override;
private:
    GL::VAO* _current_vao;
    GL::Program* _current_program;
    float _uniform;
    void clear_color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = 1.0);
public:
    OGLWidget(QWidget* parent = nullptr);
    ~OGLWidget();
    void timerEvent(QTimerEvent*) override;
public slots:
};

OGLWidget.cpp

#include "oglwidget.h"
OGLWidget::OGLWidget(QWidget* parent)
    : QOpenGLWidget(parent)
{
    _uniform = 0.0f;
    this->startTimer(10);
}
OGLWidget::~OGLWidget()
{
    delete _current_vao;
    delete _current_program;
}
void OGLWidget::initializeGL()
{
    if(!initializeOpenGLFunctions())
    {
        throw std::runtime_error("Could not initialize QOpenGLFunctions!");
    }
    auto* functions = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
    _current_vao = new GL::VAO(functions);
    _current_program = new GL::Program(functions, "first");
    //Vertices
    _current_vao->add_VBO(
    {
        {-0.5f,  0.5f, 0.f},
        {-0.5f, -0.5f, 0.f},
        { 0.5f,  0.5f, 0.f},
        { 0.5f, -0.5f, 0.f},
    });
    _current_vao->add_vertices(
    {
        0, 1, 2,
        2, 1, 3
    });
    //Colors
    _current_vao->add_VBO(
    {
        { 1, 0, 0},
        { 0, 0, 1},
        { 0, 1, 0},
        { 1, 0, 0},
    });

    _current_program->bind_attribute(0, "position");
    _current_program->bind_attribute(1, "color");
    _current_program->link();
    _current_program->use();
}
void OGLWidget::resizeGL(int width, int height)
{
    glViewport(0, 0, width, height);
}
void OGLWidget::paintGL()
{
    _uniform += 0.05f;
    _current_program->set_float("animation", glm::sin(_uniform) * 0.5f + 0.5f);
    clear_color(50, 50, 50);
    glClear(GL_COLOR_BUFFER_BIT);
    _current_vao->draw(GL_TRIANGLES);
}
void OGLWidget::timerEvent(QTimerEvent*)
{
    repaint();
}
void OGLWidget::clear_color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
{
    glClearColor((GLclampf)(red / 255.0),
                 (GLclampf)(green / 255.0),
                 (GLclampf)(blue / 255.0),
                 (GLclampf)(alpha / 255.0));
}

GL/Program.h

#pragma once
#include <string>
#include <QOpenGLFunctions_3_3_Core>
#include <glm/glm.hpp>
#include <glm/ext.hpp>
namespace GL
{
    class Program
    {
    private:
        QOpenGLFunctions_3_3_Core* _functions;
        GLuint _program;
        GLuint _vertex_shader;
        GLuint _fragment_shader;
        GLint get_location(const std::string &name);
        GLuint load_shader(const std::string &path, GLenum shader_type);
    public:
        Program(QOpenGLFunctions_3_3_Core* functions, const std::string &name);
        ~Program();
        void link();
        void bind_attribute(GLuint index, const std::string &name);
        void use();
        void set_float(const std::string &name, const float &value);
        void set_matrix(const std::string &name, const glm::mat4 &matrix);
    };
}

GL/Program.cpp

#include "Program.h"
#include <iostream>
#include <fstream>

GL::Program::Program(QOpenGLFunctions_3_3_Core* functions, const std::string &name)
{
    _functions = functions;
    _program = _functions->glCreateProgram();
    _vertex_shader = load_shader("res/glsl/" + name + ".vert", GL_VERTEX_SHADER);
    _fragment_shader = load_shader("res/glsl/" + name + ".frag", GL_FRAGMENT_SHADER);
    if (_vertex_shader == 0 || _fragment_shader == 0)
    {
        throw std::runtime_error("Failed to create shaders!");
    }
}

GL::Program::~Program()
{
    _functions->glDetachShader(_program, _vertex_shader);
    _functions->glDetachShader(_program, _fragment_shader);
    _functions->glDeleteShader(_vertex_shader);
    _functions->glDeleteShader(_fragment_shader);
    _functions->glDeleteProgram(_program);
}

void GL::Program::link()
{
    _functions->glAttachShader(_program, _vertex_shader);
    _functions->glAttachShader(_program, _fragment_shader);
    _functions->glLinkProgram(_program);
}

void GL::Program::bind_attribute(GLuint index, const std::string &name)
{
    _functions->glBindAttribLocation(_program, index, name.c_str());
}

void GL::Program::use()
{
    _functions->glUseProgram(_program);
}

void GL::Program::set_float(const std::string &name, const float &value)
{
    _functions->glUniform1f(get_location(name), value);
}

void GL::Program::set_matrix(const std::string &name, const glm::mat4 &matrix)
{
    _functions->glUniformMatrix4fv(get_location(name), 1, GL_FALSE, glm::value_ptr(matrix));
}

GLint GL::Program::get_location(const std::string &name)
{
    return _functions->glGetUniformLocation(_program, name.c_str());
}

GLuint GL::Program::load_shader(const std::string &path, GLenum shader_type)
{
    GLuint shader = _functions->glCreateShader(shader_type);
    std::ifstream fis(path);
    std::string shaderCode = {std::istreambuf_iterator<char>(fis), std::istreambuf_iterator<char>()};
    const char *c = shaderCode.c_str();
    _functions->glShaderSource(shader, 1, &c, nullptr);

    GLint status;
    _functions->glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    char buf[0x1000];
    GLsizei length;
    _functions->glGetShaderInfoLog(shader, sizeof(buf), &length, buf);
    if (length > 0)
    {
        std::cerr << "Failed to comile shader " << path << std::endl << buf << std::endl;
        return 0;
    }
    return shader;
}

Comments

[Павел Матвеев]

Простите, всё не влезло...

VAO.h

#pragma once
#include <vector>
#include <stdexcept>
#include <glm/glm.hpp>
#include <QOpenGLFunctions_3_3_Core>
namespace GL
{
    class VAO
    {
    private:
        QOpenGLFunctions_3_3_Core* _functions;
        GLuint _vao = 0;
        std::vector<GLuint> _buffers;
        unsigned int _indices_buffer = 0;
        size_t _indices_size = 0;
    public:
        VAO(QOpenGLFunctions_3_3_Core* functions);
        VAO(const VAO &) = delete;
        ~VAO();
        void bind();
        void draw(unsigned int type);
        void add_VBO(const std::vector<float> &data);
        void add_VBO(const std::vector<glm::vec2> &data);
        void add_VBO(const std::vector<glm::vec3> &data);
        void add_VBO(const std::vector<glm::vec4> &data);
        void add_vertices(const std::vector<unsigned int> &data);
    };
}

VAO.cpp

#include "VAO.h"
GL::VAO::VAO(QOpenGLFunctions_3_3_Core* functions)
{
    _functions = functions;
    _functions->glGenVertexArrays(1, &_vao);
    bind();
}
GL::VAO::~VAO()
{
    _functions->glDeleteBuffers((GLsizei)_buffers.size(), _buffers.data());
    _functions->glDeleteVertexArrays(1, &_vao);
    _functions->glDeleteBuffers(1, &_indices_buffer);
}
void GL::VAO::bind()
{
    _functions->glBindVertexArray(_vao);
}
void GL::VAO::draw(unsigned int type)
{
    assert(_indices_buffer != 0);
    bind();
    for (GLuint i = 0; i < _buffers.size(); ++i)
    {
        _functions->glEnableVertexAttribArray(i);
    }
    _functions->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices_buffer);
    _functions->glDrawElements(type, _indices_size, GL_UNSIGNED_INT, nullptr);
    for (GLuint i = 0; i < _buffers.size(); ++i)
    {
        _functions->glDisableVertexAttribArray(i);
    }
}
void GL::VAO::add_VBO(const std::vector<float> &data)
{
    GLuint vbo;
    _functions->glGenBuffers(1, &vbo);
    _functions->glBindBuffer(GL_ARRAY_BUFFER, vbo);
    _functions->glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), data.data(), GL_STATIC_DRAW);
    _functions->glVertexAttribPointer((GLuint)_buffers.size(), 1, GL_FLOAT, GL_FALSE, 0, nullptr);
    _buffers.push_back(vbo);
}
void GL::VAO::add_VBO(const std::vector<glm::vec2> &data)
{
    GLuint vbo;
    _functions->glGenBuffers(1, &vbo);
    _functions->glBindBuffer(GL_ARRAY_BUFFER, vbo);
    _functions->glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(glm::vec2), data.data(), GL_STATIC_DRAW);
    _functions->glVertexAttribPointer((GLuint)_buffers.size(), 2, GL_FLOAT, GL_FALSE, 0, nullptr);
    _buffers.push_back(vbo);
}

void GL::VAO::add_VBO(const std::vector<glm::vec3> &data)
{
    GLuint vbo;
    _functions->glGenBuffers(1, &vbo);
    _functions->glBindBuffer(GL_ARRAY_BUFFER, vbo);
    _functions->glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(glm::vec3), data.data(), GL_STATIC_DRAW);
    _functions->glVertexAttribPointer((GLuint)_buffers.size(), 3, GL_FLOAT, GL_FALSE, 0, nullptr);
    _buffers.push_back(vbo);
}
void GL::VAO::add_VBO(const std::vector<glm::vec4> &data)
{
    GLuint vbo;
    _functions->glGenBuffers(1, &vbo);
    _functions->glBindBuffer(GL_ARRAY_BUFFER, vbo);
    _functions->glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(glm::vec4), data.data(), GL_STATIC_DRAW);
    _functions->glVertexAttribPointer((GLuint)_buffers.size(), 4, GL_FLOAT, GL_FALSE, 0, nullptr);
    _buffers.push_back(vbo);
}
void GL::VAO::add_vertices(const std::vector<unsigned int> &data)
{
    assert(_indices_buffer == 0);
    _indices_size = data.size();
    _functions->glGenBuffers(1, &_indices_buffer);
    _functions->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices_buffer);
    _functions->glBufferData(GL_ELEMENT_ARRAY_BUFFER, data.size() * sizeof(unsigned int), data.data(), GL_STATIC_DRAW);
}

[Яков Е]

Павел Матвеев, попробуйте Dependency Walker, и для интереса запустите на Линуксе. Возможно, дело в переменных окружения, может быть их стоит попробовать распечатать через какой-нибудь скрипт, а потом натравить на лог Diff.

[Павел Матвеев]

Яков Е, Вот что показал запуск Dependency Walker:
Посмотрел небольшой туториал по Dependency Walker, но всё равно не совсем понял: мне просто нужно сбойные .dll файлы закинуть в папку с .exe-файлом программы ?
И, похоже, действительно проблема в переменных окружения, т.к. сбойные .dll-файлы есть на компьютере (проверил).

[Яков Е]

Павел Матвеев, я так понимаю, это вообще системные библиотеки уровня ядра, не находятся по техническим причинам. Если приложение запустилось, то по идее, все требуемые библиотеки есть, но может не хватать плагинов.

[Павел Матвеев]

Яков Е, Пишу поздновато, но только СЕЙЧАС заметил, что при использовании windeployqt.exe выдаётся предупреждение:
Поискал информацию об этом, и, как решение, нашёл запуск vsvars32.bat, но я нигде не нашёл такой батник... У меня VS 2019 - быть может, в этой версии по-другому называется этот батник ?

[Яков Е]

Павел Матвеев, так получается наоборот, работает только с этим варнингом? Что, если использовать Qt основанную на MinGW?

[Павел Матвеев]

Яков Е, У меня такого комплекта даже нет - сейчас же установлю.
Ещё я попробовал собрать программу на другом компьютере и тоже msvc2019 - та же проблема при том, что другие программы собираются нормально...

[Павел Матвеев]

Яков Е,
Собрал на MinGW64
Те же проблемы, и тоже есть предупреждение, но более "красноречивое":

Не уже ли проблема может быть только в этом ?

[Яков Е]

Павел Матвеев, давайте ещё раз уточним. У вас и на MinGW из криатора показывает черный квадрат, а после деплоя и запуска через проводник всё нормально?

[Павел Матвеев]

Яков Е, Всё так

[Павел Матвеев]

Яков Е, Оу, нет, прошу прощения
Не тот файл запустил. Из проводника собранный на MinGW тоже выводит только чёрный квадрат. Т.е. ни откуда не работает.