Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. General and Desktop
  4. Rendering issue in QOpenGLWindow
Forum Update on Monday, May 27th 2025

Rendering issue in QOpenGLWindow

Scheduled Pinned Locked Moved Unsolved General and Desktop
opengl
3 Posts 2 Posters 625 Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • J Offline
    J Offline
    Julius Aetherwing
    wrote on 13 Apr 2020, 18:02 last edited by
    #1

    Hello everyone!
    I'm pretty new to Qt, so I hope, I posted this to the right subforum.
    I am trying to create an application with OpenGL Rendering, so I decided to use QOpenGLWindow for the job. However, I could barely find any tutorials on this, which show a simple example. Additionally, I'm not too familiar with OpenGL, so obviously, things don't work as expected.

    I tried to create a simple triangle in the viewport, however it seems that the vertex shader doesn't receive the coordinate data. When I try to render the data as a triangle, I see nothing. When I try to render it as GL_POINTS instead, I see a single pixel at the origin. If I add a constant to the coordinates in the vertex shader, I can move that pixel, so obviously I messed up the data pipeline from the vertex buffer to the shader and only zeroes arrive.

    I would appreciate any hints on what might have gone wrong with the way I set up the GL state.

    main.cpp:

    #include <QApplication>
    
    #include "Window.h"
    
    int main(int argc, char* argv[]) {
      QApplication app{argc, argv};
      
      QSurfaceFormat format;
      format.setDepthBufferSize(4);
      format.setSamples(24);
      format.setVersion(3, 1);
      format.setRenderableType(QSurfaceFormat::OpenGL);
      
      Window w;
      w.show();
      
      return app.exec();
    }
    

    Window.h:

    #ifndef QTGL__WINDOW_H
    #define QTGL__WINDOW_H
    
    #include <QOpenGLFunctions>
    #include <QOpenGLWindow>
    #include <QOpenGLBuffer>
    #include <QOpenGLShaderProgram>
    #include <QOpenGLVertexArrayObject>
    
    class Window : public QOpenGLWindow, protected QOpenGLFunctions {
    public:
      Window();
      ~Window();
    
    protected:
      void initializeGL() override;
      void resizeGL(int w, int h) override;
      void paintGL() override;
      
    private:
      QOpenGLVertexArrayObject vao_;
      QOpenGLBuffer vertices_;
      QOpenGLShaderProgram shader_;
    };
    
    #endif // QTGL__WINDOW_H
    
    

    Window.cpp:

    #include "Window.h"
    
    #include <QVector2D>
    
    const char *vertexShader = //
        "#version 130\n"
        "in vec2 pos;\n"
        "void main() {\n"
        "gl_Position = vec4(pos, 0.0, 1.0);\n"
        "}";
    
    const char *fragmentShader = //
        "#version 130\n"
        "out vec4 FragColor;\n"
        "void main() {\n"
        "FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "}\n";
    
    Window::Window()
        : vao_{this}, vertices_{QOpenGLBuffer::VertexBuffer}, shader_{this} {}
    
    Window::~Window() {
      vao_.destroy();
      vertices_.destroy();
    }
    
    void Window::initializeGL() {
      initializeOpenGLFunctions();
      glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
      
      shader_.addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShader);
      shader_.addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShader);
      shader_.link();
      shader_.bind();
      
      vao_.create();
      vao_.bind();
      
      QVector2D vertices[] = {{-1.0, -1.0}, //
                              {1.0, -1.0},  //
                              {0.0, 1.0}};
    
      vertices_.create();
      vertices_.setUsagePattern(QOpenGLBuffer::StaticDraw);
      vertices_.allocate(vertices, sizeof(vertices));
      vertices_.bind();
      shader_.enableAttributeArray("pos");
      shader_.setAttributeBuffer("pos", GL_FLOAT, 0, 2);
      
      vertices_.release();
      vao_.release();
      shader_.release();
    }
    
    void Window::resizeGL(int w, int h) { glViewport(0, 0, w, h); }
    
    void Window::paintGL() {
      glClear(GL_COLOR_BUFFER_BIT);
      
      shader_.bind();
      vao_.bind();
    //  glDrawArrays(GL_POINTS, 0, 3); // renders a single red pixel at 0/0
      glDrawArrays(GL_TRIANGLES, 0, 3); // renders nothing at all
      vao_.release();
      shader_.release();
    }
    

    Thank you for your time!

    1 Reply Last reply
    0
    • J Offline
      J Offline
      Julius Aetherwing
      wrote on 20 Apr 2020, 08:37 last edited by
      #2

      Anyone? Or could you maybe point me to a proper minimal (!) example using QOpenGLWidget and the QOpenGL helper classes?

      B 1 Reply Last reply 20 Apr 2020, 08:55
      0
      • J Julius Aetherwing
        20 Apr 2020, 08:37

        Anyone? Or could you maybe point me to a proper minimal (!) example using QOpenGLWidget and the QOpenGL helper classes?

        B Offline
        B Offline
        Bonnie
        wrote on 20 Apr 2020, 08:55 last edited by Bonnie
        #3

        @Julius-Aetherwing
        Sorry, I'm not familiar with OpenGL, too.
        But you can find some example code in Qt install dir, something like "C:\Qt\Examples\Qt-5.12.6\opengl"
        The docs of the examples can be found in All Qt Examples

        1 Reply Last reply
        0

        1/3

        13 Apr 2020, 18:02

        • Login

        • Login or register to search.
        1 out of 3
        • First post
          1/3
          Last post
        0
        • Categories
        • Recent
        • Tags
        • Popular
        • Users
        • Groups
        • Search
        • Get Qt Extensions
        • Unsolved