Make egui_glow painter to work on web

egui_glow/CHANGELOG.md

@@ -3,7 +3,7 @@ All notable changes to the `egui_glow` integration will be noted in this file.
 
 
 ## Unreleased
-
+* no glutin dependency in painter .
 
 ## 0.15.0 - 2021-10-24
 `egui_glow` has been newly created, with feature parity to `egui_glium`.

egui_glow/Cargo.toml

@@ -23,18 +23,24 @@ all-features = true
 
 [dependencies]
 egui = { version = "0.15.0", path = "../egui", default-features = false, features = ["single_threaded"] }
-egui-winit = { version = "0.15.0", path = "../egui-winit", default-features = false, features = ["epi"] }
-epi = { version = "0.15.0", path = "../epi", optional = true }
 
+epi = { version = "0.15.0", path = "../epi", optional = true }
 glow = "0.11"
-glutin = "0.27"
 memoffset = "0.6"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+egui-winit = { version = "0.15.0", path = "../egui-winit", default-features = false, features = ["epi"], optional = true }
+glutin = { version = "0.27.0", optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+web-sys = { version = "0.3", features=["console"] }
+wasm-bindgen = { version = "0.2" }
+
 [dev-dependencies]
 image = { version = "0.23", default-features = false, features = ["png"] }
 
 [features]
-default = ["clipboard", "default_fonts", "links", "persistence"]
+default = ["clipboard", "default_fonts", "links", "persistence", "winit"]
 
 # enable cut/copy/paste to OS clipboard.
 # if disabled a clipboard will be simulated so you can still copy/paste within the egui app.
@@ -58,3 +64,8 @@ persistence = [
 
 # experimental support for a screen reader
 screen_reader = ["egui-winit/screen_reader"]
+
+# enable glutin/winit integration.
+# if you want to use glow painter on web disable it.
+# if disabled reduce crate size and build time.
+winit= ["egui-winit","glutin"]

egui_glow/examples/pure_glow.rs

@@ -35,7 +35,6 @@ fn create_display(
 
     (gl_window, gl)
 }
-
 fn main() {
     let event_loop = glutin::event_loop::EventLoop::with_user_event();
     let (gl_window, gl) = create_display(&event_loop);

egui_glow/src/epi_backend.rs

@@ -1,24 +1,8 @@
 use crate::*;
-use egui::Color32;
 #[cfg(target_os = "windows")]
 use glutin::platform::windows::WindowBuilderExtWindows;
-use std::time::Instant;
-
-impl epi::TextureAllocator for Painter {
-    fn alloc_srgba_premultiplied(
-        &mut self,
-        size: (usize, usize),
-        srgba_pixels: &[Color32],
-    ) -> egui::TextureId {
-        let id = self.alloc_user_texture();
-        self.set_user_texture(id, size, srgba_pixels);
-        id
-    }
 
-    fn free(&mut self, id: egui::TextureId) {
-        self.free_user_texture(id);
-    }
-}
+use std::time::Instant;
 
 struct RequestRepaintEvent;
 

egui_glow/src/lib.rs

@@ -87,25 +87,32 @@
 #![allow(clippy::float_cmp)]
 #![allow(clippy::manual_range_contains)]
 
-mod painter;
+pub mod painter;
+pub use glow;
 pub use painter::Painter;
-
-#[cfg(feature = "epi")]
+#[cfg(feature = "winit")]
 mod epi_backend;
-#[cfg(feature = "epi")]
-pub use epi_backend::{run, NativeOptions};
+mod misc_util;
+mod post_process;
+mod shader_version;
+mod vao_emulate;
 
+#[cfg(not(target_arch = "wasm32"))]
 pub use egui_winit;
+#[cfg(all(feature = "epi", feature = "winit"))]
+pub use epi_backend::{run, NativeOptions};
 
 // ----------------------------------------------------------------------------
 
 /// Use [`egui`] from a [`glow`] app.
+#[cfg(feature = "winit")]
 pub struct EguiGlow {
     egui_ctx: egui::CtxRef,
     egui_winit: egui_winit::State,
     painter: crate::Painter,
 }
 
+#[cfg(feature = "winit")]
 impl EguiGlow {
     pub fn new(
         gl_window: &glutin::WindowedContext<glutin::PossiblyCurrent>,
@@ -114,7 +121,7 @@ impl EguiGlow {
         Self {
             egui_ctx: Default::default(),
             egui_winit: egui_winit::State::new(gl_window.window()),
-            painter: crate::Painter::new(gl),
+            painter: crate::Painter::new(gl, None),
         }
     }
 
@@ -190,12 +197,14 @@ impl EguiGlow {
         shapes: Vec<egui::epaint::ClippedShape>,
     ) {
         let clipped_meshes = self.egui_ctx.tessellate(shapes);
+        let dimensions: [u32; 2] = gl_window.window().inner_size().into();
+        self.painter
+            .upload_egui_texture(gl, &self.egui_ctx.texture());
         self.painter.paint_meshes(
-            gl_window,
+            dimensions,
             gl,
             self.egui_ctx.pixels_per_point(),
             clipped_meshes,
-            &self.egui_ctx.texture(),
         );
     }
 

egui_glow/src/misc_util.rs

@@ -0,0 +1,186 @@
+#![allow(unsafe_code)]
+use glow::HasContext;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::JsValue;
+
+pub(crate) fn srgbtexture2d(
+    gl: &glow::Context,
+    is_webgl_1: bool,
+    srgb_support: bool,
+    data: &[u8],
+    w: usize,
+    h: usize,
+) -> glow::Texture {
+    assert_eq!(data.len(), w * h * 4);
+    assert!(w >= 1);
+    assert!(h >= 1);
+    unsafe {
+        let tex = gl.create_texture().unwrap();
+        gl.bind_texture(glow::TEXTURE_2D, Some(tex));
+
+        gl.tex_parameter_i32(
+            glow::TEXTURE_2D,
+            glow::TEXTURE_MAG_FILTER,
+            glow::LINEAR as i32,
+        );
+        gl.tex_parameter_i32(
+            glow::TEXTURE_2D,
+            glow::TEXTURE_MIN_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,
+        );
+        if is_webgl_1 {
+            let format = if srgb_support {
+                glow::SRGB_ALPHA
+            } else {
+                glow::RGBA
+            };
+            gl.tex_image_2d(
+                glow::TEXTURE_2D,
+                0,
+                format as i32,
+                w as i32,
+                h as i32,
+                0,
+                format,
+                glow::UNSIGNED_BYTE,
+                Some(data),
+            );
+        } else {
+            gl.tex_storage_2d(glow::TEXTURE_2D, 1, glow::SRGB8_ALPHA8, w as i32, h as i32);
+            gl.tex_sub_image_2d(
+                glow::TEXTURE_2D,
+                0,
+                0,
+                0,
+                w as i32,
+                h as i32,
+                glow::RGBA,
+                glow::UNSIGNED_BYTE,
+                glow::PixelUnpackData::Slice(data),
+            );
+        }
+        assert_eq!(gl.get_error(), glow::NO_ERROR, "OpenGL error occurred!");
+        tex
+    }
+}
+
+pub(crate) unsafe fn as_u8_slice<T>(s: &[T]) -> &[u8] {
+    std::slice::from_raw_parts(s.as_ptr().cast::<u8>(), s.len() * std::mem::size_of::<T>())
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn glow_debug_print(s: impl Into<JsValue>) {
+    web_sys::console::log_1(&s.into());
+}
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn glow_debug_print(s: impl std::fmt::Display) {
+    println!("{}", s);
+}
+
+pub(crate) fn compile_shader(
+    gl: &glow::Context,
+    shader_type: u32,
+    source: &str,
+) -> Result<glow::Shader, String> {
+    let shader = unsafe { gl.create_shader(shader_type) }?;
+    unsafe {
+        gl.shader_source(shader, source);
+    }
+    unsafe {
+        gl.compile_shader(shader);
+    }
+
+    if unsafe { gl.get_shader_compile_status(shader) } {
+        Ok(shader)
+    } else {
+        Err(unsafe { gl.get_shader_info_log(shader) })
+    }
+}
+
+pub(crate) fn link_program<'a, T: IntoIterator<Item = &'a glow::Shader>>(
+    gl: &glow::Context,
+    shaders: T,
+) -> Result<glow::Program, String> {
+    let program = unsafe { gl.create_program() }?;
+    unsafe {
+        for shader in shaders {
+            gl.attach_shader(program, *shader);
+        }
+    }
+    unsafe {
+        gl.link_program(program);
+    }
+
+    if unsafe { gl.get_program_link_status(program) } {
+        Ok(program)
+    } else {
+        Err(unsafe { gl.get_program_info_log(program) })
+    }
+}
+///Wrapper around Emulated VAO and GL's VAO
+pub(crate) enum VAO {
+    Emulated(crate::vao_emulate::EmulatedVao),
+    Native(crate::glow::VertexArray),
+}
+
+impl VAO {
+    pub(crate) unsafe fn new(gl: &glow::Context, is_native_vao: bool) -> Self {
+        if is_native_vao {
+            Self::Native(gl.create_vertex_array().unwrap())
+        } else {
+            Self::Emulated(crate::vao_emulate::EmulatedVao::new())
+        }
+    }
+    pub(crate) unsafe fn bind_vertex_array(&self, gl: &glow::Context) {
+        match self {
+            VAO::Emulated(vao) => vao.bind_vertex_array(gl),
+            VAO::Native(vao) => gl.bind_vertex_array(Some(*vao)),
+        }
+    }
+    pub(crate) fn bind_buffer(&mut self, gl: &glow::Context, buffer: &glow::Buffer) {
+        match self {
+            VAO::Emulated(vao) => vao.bind_buffer(buffer),
+            VAO::Native(_) => unsafe {
+                gl.bind_buffer(glow::ARRAY_BUFFER, Some(*buffer));
+            },
+        }
+    }
+    pub(crate) fn add_new_attribute(
+        &mut self,
+        gl: &glow::Context,
+        buffer_info: crate::vao_emulate::BufferInfo,
+    ) {
+        match self {
+            VAO::Emulated(vao) => vao.add_new_attribute(buffer_info),
+            VAO::Native(_) => unsafe {
+                gl.vertex_attrib_pointer_f32(
+                    buffer_info.location,
+                    buffer_info.vector_size,
+                    buffer_info.data_type,
+                    buffer_info.normalized,
+                    buffer_info.stride,
+                    buffer_info.offset,
+                );
+                gl.enable_vertex_attrib_array(buffer_info.location);
+            },
+        }
+    }
+    pub(crate) fn unbind_vertex_array(&self, gl: &glow::Context) {
+        match self {
+            VAO::Emulated(vao) => vao.unbind_vertex_array(gl),
+            VAO::Native(_) => unsafe {
+                gl.bind_vertex_array(None);
+            },
+        }
+    }
+}