Works

use glow::HasContext;
use glow as gl;

const WIDTH: u32 = 800;
const HEIGHT: u32 = 600;

/// # Safety:
/// * `T` must have no padding bits.
unsafe fn as_u8_slice<T>(slice: &[T]) -> &[u8] {
    unsafe {
        core::slice::from_raw_parts(
            slice.as_ptr().cast(),
            std::mem::size_of_val(slice)
        )
    }
}

type PreludeReturn = (
    sdl2::Sdl,
    sdl2::EventPump,
    sdl2::VideoSubsystem,
    sdl2::video::Window,
    sdl2::video::GLContext,
    glow::Context,
);

unsafe fn prelude() -> PreludeReturn {
    let sdl = sdl2::init().unwrap();
    let event_loop = sdl.event_pump().unwrap();
    let video = sdl.video().unwrap();

    let gl_attr = video.gl_attr();
    gl_attr.set_context_profile(sdl2::video::GLProfile::Core);
    gl_attr.set_context_version(3, 3);

    let window = video.window(
        "opengl!!",
        WIDTH,
        HEIGHT,
    ).opengl()
    .resizable()
    .build()
    .unwrap();

    let ctx = window.gl_create_context().unwrap();

    let gl = unsafe {
        glow::Context::from_loader_function(
            |s| video.gl_get_proc_address(s) as *const _
        )
    };

    unsafe {
        gl.viewport(0, 0, WIDTH as i32, HEIGHT as i32);
    }

    (sdl, event_loop, video, window, ctx, gl)
}

fn main() {unsafe {
    let (
        _sdl,
        mut event_loop,
        _video,
        window,
        _ctx,
        gl
    ) = prelude();

    let vss = r#"#version 330 core
    layout (location = 0) in vec3 aPos;

    void main() {
        gl_Position = vec4(aPos, 1.0);
    }"#;
    let vshader = gl.create_shader(gl::VERTEX_SHADER)
        .unwrap();
    gl.shader_source(vshader, vss);
    gl.compile_shader(vshader);
    if !gl.get_shader_compile_status(vshader) {
        let err = gl.get_shader_info_log(vshader);
        panic!("Vertex shader compilation error: {err}");
    }

    let fss = r#"#version 330 core
    out vec4 FragColor;
    void main()
    {
        FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
    }"#;
    let fshader = gl.create_shader(gl::FRAGMENT_SHADER)
        .unwrap();
    gl.shader_source(fshader, fss);
    gl.compile_shader(fshader);
    if !gl.get_shader_compile_status(fshader) {
        let err = gl.get_shader_info_log(fshader);
        panic!("Fragment shader compilation error: {err}");
    }

    let shader_program = gl.create_program().unwrap();
    gl.attach_shader(shader_program, vshader);
    gl.attach_shader(shader_program, fshader);
    gl.link_program(shader_program);

    gl.use_program(Some(shader_program));

    gl.delete_shader(vshader);
    gl.delete_shader(fshader);

    let vertices1: &[f32] = &[
        -1.0, -0.5, 0.0,
        0.0, -0.5, 0.0,
        -0.5, 0.5, 0.0,
    ];

    let vertices2: &[f32] = &[
        0.0, -0.5, 0.0,
        1.0, -0.5, 0.0,
        0.5, 0.5, 0.0,
    ];

    let vao1 = gl.create_vertex_array().unwrap();
    let vao2 = gl.create_vertex_array().unwrap();

    let vbo1 = gl.create_buffer().unwrap();
    let vbo2 = gl.create_buffer().unwrap();

    gl.bind_vertex_array(Some(vao1));
    gl.bind_buffer(gl::ARRAY_BUFFER, Some(vbo1));
    gl.buffer_data_u8_slice(
        gl::ARRAY_BUFFER,
        as_u8_slice(vertices1),
        gl::STATIC_DRAW,
    );
    gl.vertex_attrib_pointer_f32(
        0,
        3,
        gl::FLOAT,
        false,
        3 * size_of::<f32>() as i32,
        0,
    );
    gl.enable_vertex_attrib_array(0);

    gl.bind_vertex_array(Some(vao2));
    gl.bind_buffer(gl::ARRAY_BUFFER, Some(vbo2));
    gl.buffer_data_u8_slice(
        gl::ARRAY_BUFFER,
        as_u8_slice(vertices2),
        gl::STATIC_DRAW,
    );
    gl.vertex_attrib_pointer_f32(
        0,
        3,
        gl::FLOAT,
        false,
        3 * size_of::<f32>() as i32,
        0,
    );
    gl.enable_vertex_attrib_array(0);

    gl.bind_vertex_array(None);

    gl.clear_color(0.2, 0.3, 0.3, 1.0);
    gl.clear(gl::COLOR_BUFFER_BIT);

    gl.bind_vertex_array(Some(vao2));
    gl.draw_arrays(gl::TRIANGLES, 0, 3);
    gl.bind_vertex_array(Some(vao1));
    gl.draw_arrays(gl::TRIANGLES, 0, 3);

    window.gl_swap_window();

    let mut running = true;
    while running {
        for event in event_loop.poll_iter() {
            use sdl2::{event::{Event, WindowEvent}, keyboard::Keycode};
            match event {
                Event::Quit { .. } | Event::KeyDown { keycode: Some(Keycode::Escape), .. }
                    => running = false,
                Event::Window { win_event: WindowEvent::Resized(w, h),.. } =>
                    gl.viewport(0, 0, w, h),
                _ => {},
            }
        }

        std::thread::sleep(std::time::Duration::from_secs_f32(1.0 / 60.0));
    }
}}