vertex_attrib_pointer_f32 not stored in VAO during init

[Siroza]

Might not be egui-related but I'm pretty lost.

I'm creating/binding a VAO, calling vertex_attrib_pointer_f32, and unbinding the VAO.
When I bind the VAO to render, I get a garbage result unless I call vertex_attrib_pointer_f32 again.
This second call only has to happen once - I can wrap it with std::sync::Once and all future succeed.
The VBO remains bound so the VAO itself appears to be intact.

use std::sync::{Arc, Mutex};
use eframe::{egui::{self, CentralPanel, PaintCallback, Rect}, egui_glow::CallbackFn, glow::{self, HasContext, Program, Texture, UniformLocation, VertexArray}, App, CreationContext, Frame, NativeOptions};

type Gl = Arc<glow::Context>;

const SRC_FRAGMENT: &str = "
#version 430

layout(location = 0) out vec4 color;

in vec2 fragment_uv;

uniform sampler2D sampler;

void main() {
	color = texture(sampler, fragment_uv);
}
";
const SRC_VERTEX: &str = "
#version 430

layout(location = 0) in vec2 xy;
layout(location = 1) in vec2 uv;

out vec2 fragment_uv;

void main() {
	fragment_uv = uv;
	gl_Position = vec4(xy, 0, 1);
}
";

unsafe fn build_program(gl: &glow::Context, sources: &[(u32, &str)]) -> Program {
	let program = gl.create_program().unwrap();

	let mut shaders = Vec::with_capacity(sources.len());
	for (kind, src) in sources {
		let shader = gl.create_shader(*kind).unwrap();
		gl.shader_source(shader, src);
		gl.compile_shader(shader);
		if !gl.get_shader_compile_status(shader) {
			panic!("{}", gl.get_shader_info_log(shader));
		}
		gl.attach_shader(program, shader);

		shaders.push(shader);
	}

	gl.link_program(program);
	if !gl.get_program_link_status(program) {
		panic!("{}", gl.get_program_info_log(program));
	}

	for shader in shaders {
		gl.detach_shader(program, shader);
		gl.delete_shader(shader);
	}

	program
}

unsafe fn build_texture(gl: &Gl) -> Texture {
	let buffer = [
		255, 0, 0, 255, // red top left
		0, 255, 0, 255, // green top right
		0, 0, 255, 255, // blue bottom left
		0, 0, 0, 255    // black bottom right
	];
	let texture = gl.create_texture().unwrap();
	gl.bind_texture(glow::TEXTURE_2D, Some(texture));
	gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::LINEAR as i32);
	gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::LINEAR as i32);
	gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
	gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
	gl.tex_image_2d(glow::TEXTURE_2D, 0, glow::RGBA as i32, 2, 2, 0, glow::RGBA, glow::UNSIGNED_BYTE, Some(&buffer));
	texture
}

struct ShaderInfo {
	program: Program,
	vao: VertexArray,
	sampler: UniformLocation,
	texture: Texture,
	xy: u32,
	uv: u32,
}

struct AppWrapper {
	shader: Arc<Mutex<ShaderInfo>>,
}

impl AppWrapper {
	unsafe fn new(cc: &CreationContext<'_>) -> Self {
		let gl = cc.gl.as_ref().unwrap();

		let vao = gl.create_vertex_array().unwrap();
		gl.bind_vertex_array(Some(vao));

		let vbo = gl.create_buffer().unwrap();
		gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo));

		let program = build_program(gl, &[(glow::FRAGMENT_SHADER, SRC_FRAGMENT), (glow::VERTEX_SHADER, SRC_VERTEX)]);
		let xy = gl.get_attrib_location(program, "xy").unwrap();
		let uv = gl.get_attrib_location(program, "uv").unwrap();
		// FIXME these vertex_attrib_pointer calls do nothing
		gl.vertex_attrib_pointer_f32(xy, 2, glow::FLOAT, false, 0, 0);
		gl.vertex_attrib_pointer_f32(uv, 2, glow::FLOAT, false, 0, 48);
		gl.enable_vertex_attrib_array(xy);
		gl.enable_vertex_attrib_array(uv);

		gl.bind_vertex_array(None);

		Self {
			shader: Arc::new(Mutex::new(ShaderInfo {
				program,
				vao,
				sampler: gl.get_uniform_location(program, "sampler").unwrap(),
				texture: build_texture(gl),
				xy,
				uv,
			})),
		}
	}
}

impl App for AppWrapper {
	fn update(&mut self, ctx: &egui::Context, _: &mut Frame) {
		let style = egui::containers::Frame {
			fill: egui::Color32::LIGHT_BLUE,
			..Default::default()
		};
		CentralPanel::default().frame(style).show(ctx, |ui| {
			let vertices: [f32; 6 * 2 * 2] = [
				/*
				 * order:
				 * 0   1,4
				 * 2,3  5
				 */
				-1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, // xy
				0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0 // uv
			];

			let shader = self.shader.clone();
			ui.painter().add(PaintCallback {
				rect: Rect::EVERYTHING,
				callback: Arc::new(CallbackFn::new(move |_, painter| {
					let gl = painter.gl();
					let shader = shader.lock().unwrap();

					unsafe {
						gl.use_program(Some(shader.program));
						gl.bind_vertex_array(Some(shader.vao));

						gl.blend_func(glow::SRC_ALPHA, glow::ONE_MINUS_SRC_ALPHA);

						let ptr = vertices.as_ptr() as *const u8;
						let mutated = std::slice::from_raw_parts(ptr, vertices.len() * 4);
						gl.buffer_data_u8_slice(glow::ARRAY_BUFFER, mutated, glow::STATIC_DRAW);

						gl.active_texture(glow::TEXTURE0);
						gl.uniform_1_i32(Some(&shader.sampler), 0);
						gl.bind_texture(glow::TEXTURE_2D, Some(shader.texture));

						// FIXME must vertex_attrib_pointer here or it doesn't render correctly
						// gl.vertex_attrib_pointer_f32(shader.xy, 2, glow::FLOAT, false, 0, 0);
						// gl.vertex_attrib_pointer_f32(shader.uv, 2, glow::FLOAT, false, 0, 48);

						gl.draw_arrays(glow::TRIANGLES, 0, 6);

						gl.bind_vertex_array(None);
						gl.use_program(None);

					}
				}))
			});
		});
	}
}

fn main() {
	eframe::run_native("minimal example", NativeOptions::default(), Box::new(|cc| {
		Ok(Box::new(unsafe { AppWrapper::new(cc) }))
	})).unwrap();
}

Stock Cargo.toml with:

eframe = { version = "0.29", default-features = false, features = [
	"default_fonts",
	"glow",
]}

With the duplicate calls:

Without:

The incorrect render always has that shape and the color is always uniform based on UV (0,0) in the texture.

The vertex_attrib_pointer_f32 calls are identical and I haven't solved this over 2-3 days. Does anyone see the problem in my MRE, or have theories about how egui and friends are interfering?