OpenGL moving objects have black trail

Question

Info

• GLEW 2.1; OpenGL: 4.3
• GLFW
• glm for math
• Windows 11
• 2D
• Inspired by LearnOpenGl Tutorial

Problem

When i am trying to draw OpenGL "objects" ( basically a vao with a vbo ) and move them via a uniform matrix in my vertex shader for some reason red and blue objects have a weird black trail. I have a video showcasing the problem here. In the video it is not visible on every screen or device for some reason. On things like phones you cannot really see it because of Youtube's compression.

Working example from last project

What I tried

• Setting up a totally new project from scratch ( the one below )
• Trying it with textures

If you want to compile yourself i have a repository here

Steps to reproduce

Includes

#include <iostream>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

Create Window

GLFWwindow* window;
void init_window() {
    glewExperimental = true; // Needed for core profile
    if (!glfwInit())
    {
        printf("Failed to initialize GLFW");
        return;
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // OpenGL 4.3
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    window = glfwCreateWindow((int) 1366, (int) 768, "Game", nullptr,
                              nullptr);
    if (window == nullptr)
    {
        printf("Failed to open GLFW window.");
        glfwTerminate();
        return;
    }

    glfwMakeContextCurrent(window);
    glewExperimental = true;
    if (glewInit() != GLEW_OK)
    {
        printf("Failed to initialize GLFW");
        return;
    }
}

Create rectangle

float vertices[] = {
        // Triangle 1
        -1.0f, -1.0f, // Bottom-Right
        1.0f, -1.0f, // Bottom-Left
        1.0f, 1.0f, // Top-Left
        // Triangle 2
        -1.0f, 1.0f, // Top-Right
        1.0f, 1.0f, // Top-Left
        -1.0f, -1.0f, // Bottom-Right
};

GLuint vbo;
void init_vbo() {
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof (vertices), vertices, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

GLuint vao;
void init_vao() {
    init_vbo();
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof (float), nullptr);
    glEnableVertexAttribArray(0);
}

Initialize shaders

const char* vShader = "#version 430 core\n"
                      "\n"
                      "layout(location = 0) in vec2 vertex;\n"
                      "\n"
                      "uniform mat4 model;\n"
                      "uniform mat4 projection;\n"
                      "\n"
                      "void main() {\n"
                      "    gl_Position = projection * model * vec4(vertex.xy, 0.0f, 1.0f);\n"
                      "}";
const char* fShader = "#version 430 core\n"
                      "\n"
                      "out vec4 outColor;\n"
                      "\n"
                      "uniform vec3 color;\n"
                      "\n"
                      "void main() {\n"
                      "        outColor = vec4(color, 1.0);\n"
                      "}";
GLuint shader;
void init_shader() {

    GLuint vShaderId = glCreateShader(GL_VERTEX_SHADER);
    GLuint fShaderId = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(vShaderId, 1, &vShader, nullptr);
    glCompileShader(vShaderId);

    glShaderSource(fShaderId, 1, &fShader, nullptr);
    glCompileShader(fShaderId);

    shader = glCreateProgram();
    glAttachShader(shader, vShaderId);
    glAttachShader(shader, fShaderId);
    glLinkProgram(shader);

    glDeleteShader(vShaderId);
    glDeleteShader(fShaderId);

    // Set projection matrix
    glUseProgram(shader);
    auto projection = glm::ortho(0.0f, 1366.0f, 768.0f, 0.0f, -1.0f, 1.0f);
    GLint loc = glGetUniformLocation(shader, "projection");
    glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
}

Program loop

glm::mat4 gen_matrix(glm::vec2 position, glm::vec2 size, float rotation) {
    glUseProgram(shader);
    auto model = glm::mat4(1.0f);
    model = glm::translate(model, glm::vec3(position, 0.0f));

    model = glm::translate(model, glm::vec3(0.5f * size.x, 0.5f * size.y, 0.0f));
    model = glm::rotate(model, glm::radians(rotation), glm::vec3(0.0f, 0.0f, 1.0f));
    model = glm::translate(model, glm::vec3(-0.5f * size.x, -0.5f * size.y, 0.0f));

    model = glm::scale(model, glm::vec3(size, 1.0f));
    return model;
}

[[noreturn]] void loop() {
    glUseProgram(shader);
    // Set color
    glm::vec3 color(1.0f, 0.0f, 0.0f);
    GLint colorPos = glGetUniformLocation(shader, "color");
    glUniform3f(colorPos, color.x, color.y, color.z);

    
    GLint modelMatPos = glGetUniformLocation(shader, "model");
    glm::vec2 pos(200.0f, 200.0f);
    glm::vec2 size(40.0f, 40.0f);

    glBindVertexArray(vao);
    while(true) {
        glfwPollEvents();
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glUniformMatrix4fv(modelMatPos, 1, GL_FALSE, glm::value_ptr(gen_matrix(pos, size, 0)));
        pos += 1;
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glfwSwapBuffers(window);
    }
}

Main

int main()
{

    init_window();
    init_vao();
    init_shader();
    loop();
    return 0;
}