glow backend depth testing not working

[GraydenH]

Hi, I'm trying to draw a simple 3d pyramid but I can't get depth testing to work. I'm using egui because i plan to use it later. I can't figure out what else would interfere. I tried setting the depth test values every frame but no change

    pub fn draw(&self, rotation: f32) {
        unsafe {
            // Shader sources
            const TEXTURE_VS_SRC: &str = "
                #version 330 core

                layout (location = 0) in vec3 aposition;
                layout (location = 1) in vec3 acolor;
                layout (location = 2) in vec2 atexture_coordinate;

                out vec3 color;
                out vec2 texture_coordinate;

                uniform mat4 model;
                uniform mat4 view;
                uniform mat4 projection;

                void main()
                {
                    gl_Position = projection * view * model * vec4(aposition, 1.0);
                    color = acolor;
                    texture_coordinate = atexture_coordinate;
                }
            ";

            const TEXTURE_FS_SRC: &str = "
                #version 330 core

                // Outputs colors in RGBA
                out vec4 FragColor;

                // Inputs the color from the Vertex Shader
                in vec3 color;
                // Inputs the texture coordinates from the Vertex Shader
                in vec2 texture_coordinate;

                // Gets the Texture Unit from the main function
                uniform sampler2D tex0;

                void main()
                {
                    FragColor = texture(tex0, texture_coordinate);
                }
            ";

            // Vertices coordinates
            let VERTICES: Vec<f32> = vec![
                //     COORDINATES     /        COLORS      /   TexCoord  //
                -0.5, 0.0,  0.5,     0.83, 0.70, 0.44,	0.0, 0.0,
                -0.5, 0.0, -0.5,     0.83, 0.70, 0.44,	5.0, 0.0,
                0.5, 0.0, -0.5,     0.83, 0.70, 0.44,	0.0, 0.0,
                0.5, 0.0,  0.5,     0.83, 0.70, 0.44,	5.0, 0.0,
                0.0, 0.8,  0.0,     0.92, 0.86, 0.76,	2.5, 5.0
            ];

            // Indices for vertices order
            let INDICES: Vec<u32> = vec![
                0, 1, 2,
                0, 2, 3,
                0, 1, 4,
                1, 2, 4,
                2, 3, 4,
                3, 0, 4
            ];

            self.gl.clear_depth_f32(1.0);
            self.gl.depth_func(glow::LESS);
            self.gl.depth_mask(true);
            self.gl.enable(glow::DEPTH_TEST);
            self.gl.clear_color(0.3, 0.3, 0.3, 1.0);
            self.gl.clear(glow::COLOR_BUFFER_BIT | glow::DEPTH_BUFFER_BIT);
            let shader = Shader::new(&self.gl, TEXTURE_VS_SRC, TEXTURE_FS_SRC);
            shader.bind(&self.gl);
            shader.upload_uniform_mat4(&self.gl, "model",  &glm::rotate(&glm::identity(), rotation, &glm::vec3(0.0, 1.0, 0.0)));
            shader.upload_uniform_mat4(&self.gl, "view",  &glm::translate(&glm::identity(), &glm::vec3(0.0, -0.5, -2.0)));
            shader.upload_uniform_mat4(&self.gl, "projection",  &Mat4::new_perspective((800.0 / 600.0), 45.0, 1.0, 100.0));

            let mut texture = Texture::new(String::from("sandbox/assets/textures/checkerboard.png"), 1.0);
            texture.init(&self.gl);
            Texture::bind(&self.gl, texture.get_renderer_id().unwrap(), 0);

            shader.upload_uniform_integer1(&self.gl, "tex0", 0);

            let layout = BufferLayout::new(
                vec![
                    BufferElement::new("aposition".parse().unwrap(), ShaderDataType::Float3, false),
                    BufferElement::new("acolor".parse().unwrap(), ShaderDataType::Float3, false),
                    BufferElement::new("atexture_coordinate".parse().unwrap(), ShaderDataType::Float2, false),
                ]
            );

            let index_buffer = IndexBuffer::new(&self.gl, INDICES);
            let vertex_buffer = VertexBuffer::new(&self.gl, VERTICES, layout);
            let vertex_array = VertexArray::new(&self.gl, index_buffer, vertex_buffer);

            self.gl.draw_elements(glow::TRIANGLES, vertex_array.get_indices_len() as i32, glow::UNSIGNED_INT, 0);
        }
    }

app.run, where the egui code is found

    pub fn run(self) {
        let event_loop = glutin::event_loop::EventLoop::with_user_event();

        let (gl_window, gl) = create_display(&event_loop, self.title.as_str());

        let mut egui = egui_glow::EguiGlow::new(&gl_window, &gl);

        let mut renderer = Renderer::new(gl);
        //let mut renderer_2d = Renderer2D::new(gl);

        renderer.init();

        let mut layer_stack = self.layer_stack;

        let clock = Instant::now();
        let fixed_timestep = 1.0 / 60.0;
        let mut elapsed_time = 0.0;
        let mut dt = clock.elapsed().as_secs_f32() - elapsed_time;

        event_loop.run(move |event, _, control_flow| {
            use glutin::event::{Event};
            use glutin::event_loop::ControlFlow;

            *control_flow = ControlFlow::Wait;

            let mut redraw = || {
                egui.begin_frame(gl_window.window());

                for layer in layer_stack.iter_mut().rev() {
                    layer.on_ui_update(&egui);
                }

                let (_needs_repaint, shapes) = egui.end_frame(gl_window.window());

                {
                    // draw things behind egui here
                    dt = clock.elapsed().as_secs_f32() - elapsed_time;
                    while dt >= fixed_timestep {
                        dt -= fixed_timestep;
                        elapsed_time += fixed_timestep;

                        for layer in layer_stack.iter_mut().rev() {
                            layer.on_tick(&mut renderer);
                        }
                    }
                    egui.paint(&gl_window, renderer.borrow_context(), shapes);

                    // draw things on top of egui here

                    gl_window.swap_buffers().unwrap();
                }
            };

            match event {
                Event::RedrawEventsCleared if cfg!(windows) => redraw(),
                Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
                Event::MainEventsCleared => {
                    gl_window.window().request_redraw();
                },
                Event::DeviceEvent { event, ..} => match event {
                    DeviceEvent::Key(input) => unsafe {
                        if let Some(keycode) = input.virtual_keycode {
                            let index = keycode as u16;

                            if input.state == ElementState::Pressed {
                                let repeat = KEY_PRESSED[index as usize];
                                KEY_PRESSED[index as usize] = true;
                                for layer in layer_stack.iter_mut().rev() {
                                    layer.on_key_press(keycode, repeat);
                                }
                            } else {
                                KEY_PRESSED[index as usize] = false;
                                for layer in layer_stack.iter_mut().rev() {
                                    layer.on_key_release(keycode);
                                }
                            };
                        }
                    }
                    _ => {}
                },
                Event::WindowEvent { event, .. } => {
                    if egui.is_quit_event(&event) {
                        *control_flow = glutin::event_loop::ControlFlow::Exit;
                    }

                    if let glutin::event::WindowEvent::Resized(physical_size) = event {
                        gl_window.resize(physical_size);
                    }

                    egui.on_event(&event);

                    gl_window.window().request_redraw(); // TODO: ask egui if the events warrants a repaint instead
                }
                Event::RedrawRequested(_) => {
                    //gl_window.swap_buffers().unwrap();
                },
                Event::LoopDestroyed => {
                    egui.destroy(&renderer.borrow_context());
                }
                _ => (),
            }
        });
    }

[GraydenH]

I realized that the glutin window creation code i used set the depth buffer to 0 bits. I changed it to 24 and it worked.

while im here, my app.run code doesnt loop regularly. No events happen unless i move the mouse or something, on the first frame or anyframe after that, meaning redraw doesnt happen until then. and the keyboard input also causes a stutter on the first input. I'm not sure whats causing these issues but the egui glow backend might have something to do with it,

[AlexApps99]

It looks like your code does not call redraw every frame.
The closure redraw is only called on the events RedrawEventsCleared and RedrawRequested.

[coderedart]

MainEventsCleared is a good one to use i think

[GraydenH]

Where else would u call it logically?

[GraydenH]

Event::MainEventsCleared => {
                    redraw();
                },

this gave no change. I'm hoping to have it call on_tick 60 times a second consistently

[emilk]

Did you try calling gl_window.window().request_redraw() right after each draw call?