rust: adds mx example and minor impl polishing

example/rust/gl-glfw-mx/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "gl-glfw"
+version = "0.1.0"
+
+[dependencies]
+glfw = "0.37.0"
+glad-gl = { path = "./build/glad-gl" }
+

example/rust/gl-glfw-mx/README.md

@@ -0,0 +1,34 @@
+Example: gl-glfw-mx
+================
+
+
+This is basic example showcasing `glad-gl` in combination with
+[`glfw`](https://crates.io/crates/glfw). And multiple OpenGL contexts
+in different windows.
+
+To run the example use the following command:
+
+```sh
+./init.sh && cargo run
+```
+
+The `init.sh` script is just a small utility used to generate
+the `glad-gl` crate into the `build/` directory. The `Cargo.toml`
+references the dependency using:
+
+```toml
+[dependencies]
+glad-gl = { path = "./build/glad-gl" }
+```
+
+This example is the basic example of the
+[glfw crate](https://crates.io/crates/glfw) with some
+OpenGL instructions added and just one additional line
+to initialize `glad`:
+
+```rust
+    gl::load(|e| glfw.get_proc_address_raw(e) as *const std::os::raw::c_void);
+```
+
+That's all that is needed to initialize and use OpenGL using `glad`!
+

example/rust/gl-glfw-mx/init.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+BASE_PATH="$(dirname $(realpath $0))"
+
+
+cd "${BASE_PATH}/../../../"
+
+python -m glad --out-path "${BASE_PATH}/build" --extensions="" --api="gl:core=3.3" rust --mx
+

example/rust/gl-glfw-mx/src/main.rs

@@ -0,0 +1,63 @@
+extern crate glfw;
+extern crate glad_gl;
+use std::sync::mpsc::Receiver;
+use glfw::{Action, Context, Key};
+use glad_gl::gl;
+
+
+struct Window {
+    source: glfw::Window,
+    events: Receiver<(f64, glfw::WindowEvent)>,
+    gl: gl::Gl
+}
+
+fn main() {
+    let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();
+
+    let mut w1 = create_window(&mut glfw);
+    let mut w2 = create_window(&mut glfw);
+
+    while !w1.source.should_close() && !w2.source.should_close() {
+        glfw.poll_events();
+
+        draw(&mut w1);
+        draw(&mut w2);
+    }
+}
+
+fn create_window(glfw: &mut glfw::Glfw) -> Window {
+    let (mut window, events) = glfw
+        .create_window(300, 300, "[glad] Rust - OpenGL with GLFW", glfw::WindowMode::Windowed)
+        .expect("Failed to create GLFW window.");
+
+    window.set_key_polling(true);
+    window.make_current();
+
+    let gl = gl::load(|e| glfw.get_proc_address_raw(e) as *const std::os::raw::c_void);
+
+    Window {
+        source: window, events, gl
+    }
+}
+
+fn draw(window: &mut Window) {
+    for (_, event) in glfw::flush_messages(&window.events) {
+        handle_window_event(&mut window.source, event);
+    }
+
+    window.source.make_current();
+    unsafe {
+        window.gl.ClearColor(0.7, 0.9, 0.1, 1.0);
+        window.gl.Clear(gl::GL_COLOR_BUFFER_BIT);
+    }
+    window.source.swap_buffers();
+}
+
+fn handle_window_event(window: &mut glfw::Window, event: glfw::WindowEvent) {
+    match event {
+        glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => {
+            window.set_should_close(true)
+        }
+        _ => {}
+    }
+}

example/rust/gl-glfw/Cargo.toml

@@ -3,6 +3,6 @@ name = "gl-glfw"
 version = "0.1.0"
 
 [dependencies]
-glfw = "0.23.0"
+glfw = "0.37.0"
 glad-gl = { path = "./build/glad-gl" }
 

glad/generator/rust/templates/impl.rs

@@ -5,11 +5,7 @@ pub use self::functions::*;
 
 use std::os::raw;
 
-{% if options.mx %}
 struct FnPtr {
-{% else %}
-pub struct FnPtr {
-{% endif %}
     ptr: *const raw::c_void,
     is_loaded: bool
 }
@@ -24,9 +20,6 @@ impl FnPtr {
         }
     }
     {% else %}
-    pub fn empty() -> FnPtr {
-        FnPtr { ptr: FnPtr::not_initialized as *const raw::c_void, is_loaded: false }
-    }
 
     pub fn load<F>(&mut self, loadfn: &mut F, name: &'static str) where F: FnMut(&'static str) -> *const raw::c_void {
         let loaded = loadfn(name);
@@ -99,14 +92,14 @@ mod storage {
     use std::os::raw;
 
     {% for command in feature_set.commands %}
-    {{ template_utils.protect(command) }} pub static mut {{ command.name|no_prefix }}: FnPtr = FnPtr { ptr: FnPtr::not_initialized as *const raw::c_void, is_loaded: false };
+    {{ template_utils.protect(command) }} pub(super) static mut {{ command.name|no_prefix }}: FnPtr = FnPtr { ptr: FnPtr::not_initialized as *const raw::c_void, is_loaded: false };
     {% endfor %}
 }
 {% endif %}
 
 {% if options.mx %}
-#[allow(unused_mut)]
 pub fn load<F>(mut loadfn: F) -> functions::Gl where F: FnMut(&'static str) -> *const raw::c_void {
+    #[allow(unused_mut)]
     let mut gl = Gl {
         {% for command in feature_set.commands %}
         {{ template_utils.protect(command.name) }} _{{ command.name|no_prefix }}: FnPtr::new(loadfn("{{ command.name }}")),