Merge pull request PistonDevelopers#352 from bvssvni/master

Published 0.88.0

Author: bvssvni

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "piston2d-opengl_graphics"
-version = "0.87.0"
+version = "0.88.0"
 edition = "2018"
 authors = [
     "bvssvni <[email protected]>",
@@ -31,19 +31,19 @@ path = "src/lib.rs"
 [features]
 default = ["gl"]
 webgl = ["gl"]
-glow = ["piston2d-glow_wrap"]
+glow = ["piston2d-glow_wrap", "dep:glow"]
 
 [dependencies]
-image = "0.25.2"
+image = {version = "0.25.2", features = ["png"]}
 
 piston-shaders_graphics2d = "0.4.0"
 piston-texture = "0.9.0"
 piston-viewport = "1.0.2"
 shader_version = "0.7.0"
 fnv = "1.0.7"
 
-piston2d-glow_wrap = { path = "glow_wrap", version = "0.1.0", optional = true}
-gl = { version = "0.14.0", optional = true}
+piston2d-glow_wrap = { path = "glow_wrap", version = "0.2.0", optional = true}
+gl = {version = "0.14.0", optional = true}
 
 
 [dependencies.piston2d-graphics]
@@ -56,11 +56,13 @@ pistoncore-sdl2_window = "0.70.0"
 rand = "0.8.5"
 tokio = {version = "1.40.0", features = ["full"]}
 futures = "0.3.31"
-glutin = "0.32.1"
-glow = "0.14.2"
+glutin = "0.32.2"
+winit = "0.30.9"
+glutin-winit = "0.5.0"
+glow = "0.16.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-glow = "0.14.2"
+glow = {version = "0.16.0", optional = true}
 web-sys = { version = "0.3.72", features = [
   "HtmlCanvasElement",
   "WebGl2RenderingContext",

examples/glow-hello_world.rs

@@ -0,0 +1,208 @@
+/*
+
+Code copied from:
+https://github.com/grovesNL/glow/blob/main/examples/hello/src/main.rs
+
+This example is used as reference for other Glow examples.
+
+*/
+
+use glow::*;
+
+fn main() {
+    unsafe {
+        // Create a context from a WebGL2 context on wasm32 targets
+        #[cfg(target_arch = "wasm32")]
+        let (gl, shader_version) = {
+            use wasm_bindgen::JsCast;
+            let canvas = web_sys::window()
+                .unwrap()
+                .document()
+                .unwrap()
+                .get_element_by_id("canvas")
+                .unwrap()
+                .dyn_into::<web_sys::HtmlCanvasElement>()
+                .unwrap();
+            let webgl2_context = canvas
+                .get_context("webgl2")
+                .unwrap()
+                .unwrap()
+                .dyn_into::<web_sys::WebGl2RenderingContext>()
+                .unwrap();
+            let gl = glow::Context::from_webgl2_context(webgl2_context);
+            (gl, "#version 300 es")
+        };
+
+        // Create a context from a glutin window on non-wasm32 targets
+        #[cfg(not(target_arch = "wasm32"))]
+        // #[cfg(feature = "glutin_winit")]
+        let (gl, gl_surface, gl_context, shader_version, _window, event_loop) = {
+            use glutin::{
+                config::{ConfigTemplateBuilder, GlConfig},
+                context::{ContextApi, ContextAttributesBuilder, NotCurrentGlContext},
+                display::{GetGlDisplay, GlDisplay},
+                surface::{GlSurface, SwapInterval},
+            };
+            use glutin_winit::{DisplayBuilder, GlWindow};
+            use winit::raw_window_handle::HasRawWindowHandle;
+            use std::num::NonZeroU32;
+
+            let event_loop = winit::event_loop::EventLoopBuilder::new().build().unwrap();
+            let window_builder = winit::window::WindowAttributes::new()
+                .with_title("Hello triangle!")
+                .with_inner_size(winit::dpi::LogicalSize::new(1024.0, 768.0));
+
+            let template = ConfigTemplateBuilder::new();
+
+            let display_builder = DisplayBuilder::new().with_window_attributes(Some(window_builder));
+
+            let (window, gl_config) = display_builder
+                .build(&event_loop, template, |configs| {
+                    configs
+                        .reduce(|accum, config| {
+                            use glutin::config::GlConfig;
+
+                            if config.num_samples() > accum.num_samples() {
+                                config
+                            } else {
+                                accum
+                            }
+                        })
+                        .unwrap()
+                })
+                .unwrap();
+
+            let raw_window_handle = window.as_ref().map(|window| window.raw_window_handle().unwrap());
+
+            let gl_display = gl_config.display();
+            let context_attributes = ContextAttributesBuilder::new()
+                .with_context_api(ContextApi::OpenGl(Some(glutin::context::Version {
+                    major: 4,
+                    minor: 1,
+                })))
+                .build(raw_window_handle);
+
+            let not_current_gl_context = gl_display
+                .create_context(&gl_config, &context_attributes)
+                .unwrap();
+
+            let window = window.unwrap();
+
+            let attrs = window.build_surface_attributes(Default::default()).unwrap();
+            let gl_surface = gl_display
+                .create_window_surface(&gl_config, &attrs)
+                .unwrap();
+
+            let gl_context = not_current_gl_context.make_current(&gl_surface).unwrap();
+
+            let gl = glow::Context::from_loader_function_cstr(|s| gl_display.get_proc_address(s));
+
+            gl_surface
+                .set_swap_interval(&gl_context, SwapInterval::Wait(NonZeroU32::new(1).unwrap()))
+                .unwrap();
+
+            (
+                gl,
+                gl_surface,
+                gl_context,
+                "#version 410",
+                window,
+                event_loop,
+            )
+        };
+
+        let vertex_array = gl
+            .create_vertex_array()
+            .expect("Cannot create vertex array");
+        gl.bind_vertex_array(Some(vertex_array));
+
+        let program = gl.create_program().expect("Cannot create program");
+
+        let (vertex_shader_source, fragment_shader_source) = (
+            r#"const vec2 verts[3] = vec2[3](
+                vec2(0.5f, 1.0f),
+                vec2(0.0f, 0.0f),
+                vec2(1.0f, 0.0f)
+            );
+            out vec2 vert;
+            void main() {
+                vert = verts[gl_VertexID];
+                gl_Position = vec4(vert - 0.5, 0.0, 1.0);
+            }"#,
+            r#"precision mediump float;
+            in vec2 vert;
+            out vec4 color;
+            void main() {
+                color = vec4(vert, 0.5, 1.0);
+            }"#,
+        );
+
+        let shader_sources = [
+            (glow::VERTEX_SHADER, vertex_shader_source),
+            (glow::FRAGMENT_SHADER, fragment_shader_source),
+        ];
+
+        let mut shaders = Vec::with_capacity(shader_sources.len());
+
+        for (shader_type, shader_source) in shader_sources.iter() {
+            let shader = gl
+                .create_shader(*shader_type)
+                .expect("Cannot create shader");
+            gl.shader_source(shader, &format!("{}\n{}", shader_version, shader_source));
+            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);
+        }
+
+        gl.use_program(Some(program));
+        gl.clear_color(0.1, 0.2, 0.3, 1.0);
+
+        // We handle events differently between targets
+
+        #[cfg(not(target_arch = "wasm32"))]
+        // #[cfg(feature = "glutin_winit")]
+        {
+            use glutin::prelude::GlSurface;
+            use winit::event::{Event, WindowEvent};
+            let _ = event_loop.run(move |event, elwt| {
+                if let Event::WindowEvent { event, .. } = event {
+                    match event {
+                        WindowEvent::CloseRequested => {
+                            elwt.exit();
+                        }
+                        WindowEvent::RedrawRequested => {
+                            gl.clear(glow::COLOR_BUFFER_BIT);
+                            gl.draw_arrays(glow::TRIANGLES, 0, 3);
+                            gl_surface.swap_buffers(&gl_context).unwrap();
+                        }
+                        _ => (),
+                    }
+                }
+            });
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        {
+            // This could be called from `requestAnimationFrame`, a winit event
+            // loop, etc.
+            gl.clear(glow::COLOR_BUFFER_BIT);
+            gl.draw_arrays(glow::TRIANGLES, 0, 3);
+            gl.delete_program(program);
+            gl.delete_vertex_array(vertex_array);
+        }
+    }
+}
+