Rust and OpenGL setup - opengl

Question

I'm trying to export my OpenGL game from C++ to Rust and achieve 2 things:
1. Print OpenGL error messages to console.
2. Autocompletion of GL functions and constants in my IDE (Visual Studio Code).
I simly generated OpenGL bindings with gl_generator crate and copied bindings.rs file to my cargo.
extern crate sdl2;
mod bindings;
use bindings as GL;
fn main() {
let sdl = sdl2::init().unwrap();
let mut event_pump = sdl.event_pump().unwrap();
let video_subsystem = sdl.video().unwrap();
let gl_attr = video_subsystem.gl_attr();
gl_attr.set_context_profile(sdl2::video::GLProfile::Core);
gl_attr.set_context_version(4, 5);
let window = video_subsystem.window("Window", 900, 700).opengl().resizable().build().unwrap();
let _gl_context = window.gl_create_context().unwrap();
let gl = GL::Gl::load_with(|s| video_subsystem.gl_get_proc_address(s) as *const std::os::raw::c_void);
unsafe{ gl.Viewport(0, 0, 900, 700); }
'main: loop {
unsafe {
gl.UseProgram(42); // <- error (^ GL error triggered: 1281)
gl.ClearColor(0.0, 0.3, 0.6, 1.0 );
gl.Clear(GL::COLOR_BUFFER_BIT);
}
window.gl_swap_window();
for event in event_pump.poll_iter() {
match event {
sdl2::event::Event::Quit {..} => { break 'main },
_ => {},
}
}
}
}
The problem is that gl variable, where all functions are stored, is not global and I'm not sure how to use it with different modules/functions.
The reason why all functions are inside Gl struct is because I used DebugStructGenerator in my build function. It prints not only errors but all OpenGL function calls (e.g., [OpenGL] ClearColor(0.0, 0.3, 0.6, 1.0)). Would be great if it only printed error messages.
My build.rs file:
extern crate gl_generator;
use gl_generator::{Registry, Fallbacks, /*StructGenerator, GlobalGenerator,*/ DebugStructGenerator, Api, Profile};
use std::env;
use std::fs::File;
use std::path::Path;
fn main() {
let out_dir = env::var("OUT_DIR").unwrap();
let mut file_gl = File::create(&Path::new(&out_dir).join("bindings.rs")).unwrap();
let registry = Registry::new(Api::Gl, (4, 5), Profile::Core, Fallbacks::All, [ "GL_NV_command_list" ]);
registry.write_bindings(DebugStructGenerator, &mut file_gl).unwrap();
}

Answer 1

There is no need to include the bindings.rs:
pub mod gl {
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
}
Include this in your main.rs or lib.rs. Then you can include the gl functions from any of your modules just with (as gl is includes as pub module):
// anywhere in a module
use crate::gl; // static gl with lot of constants e.g gl::ARRAY_BUFFER
use crate::gl::Gl; // gl instance struct with gl: &Gl => gl.bindBuffer(...)
use crate::gl::types::*; // include all gl types like GLuint, GLenum, ...
As we are in rust, you need to provide your gl instance to your functions as reference or whatever you want.
Maybe check lazy_static, which can be used as global variable:
lazy_static! {
pub static ref gl: gl::Gl = create_opengl_context();
}
First access to gl will call the create context function. Repeated calls will use the created instance.
Maybe have a look at my game-gl library (graphics branch) at
https://github.com/Kaiser1989/game-gl or the example at https://github.com/Kaiser1989/rust-android-example. (Android and Windows openGL game loop framework)
.