openGL(pyglet) 3d scene not rendering properly on AMD Graphics card

Question

I have found code that renders a cube with pyglet and I watched the video that goes along with the code, It shows the cube rendering properly on a Nvidia graphics card. When I tried the code on my AMD graphics card it breaks, how can I fix this?

github link: https://github.com/obiwac/python-minecraft-clone/tree/master/episode-7

video link: https://www.youtube.com/watch?v=U9Ldr_PeRA8

What I get:

What the video shows:

Code from main.py

import math
import ctypes
import pyglet

pyglet.options["shadow_window"] = False
pyglet.options["debug_gl"] = False

import pyglet.gl as gl

import matrix
import shader
import camera

import block_type
import texture_manager

class Window(pyglet.window.Window):
    def __init__(self, **args):
        super().__init__(**args)

        # create blocks

        self.texture_manager = texture_manager.Texture_manager(16, 16, 256)

        self.cobblestone = block_type.Block_type(self.texture_manager, "cobblestone", {"all": "cobblestone"})
        self.grass = block_type.Block_type(self.texture_manager, "grass", {"top": "grass", "bottom": "dirt", "sides": "grass_side"})
        self.dirt = block_type.Block_type(self.texture_manager, "dirt", {"all": "dirt"})
        self.stone = block_type.Block_type(self.texture_manager, "stone", {"all": "stone"})
        self.sand = block_type.Block_type(self.texture_manager, "sand", {"all": "sand"})
        self.planks = block_type.Block_type(self.texture_manager, "planks", {"all": "planks"})
        self.log = block_type.Block_type(self.texture_manager, "log", {"top": "log_top", "bottom": "log_top", "sides": "log_side"})

        self.texture_manager.generate_mipmaps()

        # create vertex array object

        self.vao = gl.GLuint(0)
        gl.glGenVertexArrays(1, ctypes.byref(self.vao))
        gl.glBindVertexArray(self.vao)

        # create vertex position vbo

        self.vertex_position_vbo = gl.GLuint(0)
        gl.glGenBuffers(1, ctypes.byref(self.vertex_position_vbo))
        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertex_position_vbo)

        gl.glBufferData(
            gl.GL_ARRAY_BUFFER,
            ctypes.sizeof(gl.GLfloat * len(self.grass.vertex_positions)),
            (gl.GLfloat * len(self.grass.vertex_positions)) (*self.grass.vertex_positions),
            gl.GL_STATIC_DRAW)
        
        gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
        gl.glEnableVertexAttribArray(0)

        # create tex coord vbo

        self.tex_coord_vbo = gl.GLuint(0)
        gl.glGenBuffers(1, ctypes.byref(self.tex_coord_vbo))
        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.tex_coord_vbo)

        gl.glBufferData(
            gl.GL_ARRAY_BUFFER,
            ctypes.sizeof(gl.GLfloat * len(self.grass.tex_coords)),
            (gl.GLfloat * len(self.grass.tex_coords)) (*self.grass.tex_coords),
            gl.GL_STATIC_DRAW)
        
        gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
        gl.glEnableVertexAttribArray(1)

        # create shading value vbo

        self.shading_value_vbo = gl.GLuint(0)
        gl.glGenBuffers(1, ctypes.byref(self.shading_value_vbo))
        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.shading_value_vbo)

        gl.glBufferData(
            gl.GL_ARRAY_BUFFER,
            ctypes.sizeof(gl.GLfloat * len(self.grass.shading_values)),
            (gl.GLfloat * len(self.grass.shading_values)) (*self.grass.shading_values),
            gl.GL_STATIC_DRAW)
        
        gl.glVertexAttribPointer(2, 1, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
        gl.glEnableVertexAttribArray(2)

        # create index buffer object

        self.ibo = gl.GLuint(0)
        gl.glGenBuffers(1, self.ibo)
        gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.ibo)

        gl.glBufferData(
            gl.GL_ELEMENT_ARRAY_BUFFER,
            ctypes.sizeof(gl.GLuint * len(self.grass.indices)),
            (gl.GLuint * len(self.grass.indices)) (*self.grass.indices),
            gl.GL_STATIC_DRAW)
        
        # create shader

        self.shader = shader.Shader("vert.glsl", "frag.glsl")
        self.shader_sampler_location = self.shader.find_uniform(b"texture_array_sampler")
        self.shader.use()

        # pyglet stuff

        pyglet.clock.schedule_interval(self.update, 1.0 / 60)
        self.mouse_captured = False

        # camera stuff

        self.camera = camera.Camera(self.shader, self.width, self.height)
    
    def on_draw(self):
        self.camera.update_matrices()

        # bind textures

        gl.glActiveTexture(gl.GL_TEXTURE0)
        gl.glBindTexture(gl.GL_TEXTURE_2D_ARRAY, self.texture_manager.texture_array)
        gl.glUniform1i(self.shader_sampler_location, 0)

        # draw stuff

        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glClearColor(0.0, 0.0, 0.0, 1.0)
        self.clear()

        gl.glDrawElements(
            gl.GL_TRIANGLES,
            len(self.grass.indices),
            gl.GL_UNSIGNED_INT,
            None)

*Note: Some of the camera movement code has been left out, to see the full code, please refer to the github link.

I have talked to the creator on discord and he has confirmed that he is using a Nvidia card, any help fixing this issue is greatly appreciated!

Answer 1

You have to ensure that the default framebuffer of the pyglet window has a depth buffer. See Creating an OpenGL context:

config = pyglet.gl.Config(depth_size = 24)
window = pyglet.window.Window(config = config)

If your hardware doesn't support a 24-bit depth buffer, you may need to try 16-bit:

config = pyglet.gl.Config(depth_size = 16)
window = pyglet.window.Window(config = config)