Do all blending in gamma space

This is an experiment to investigate solutions to
* https://github.com/emilk/egui/issues/1410

.cargo/config.toml

@@ -1,6 +1,84 @@
-# clipboard api is still unstable, so web-sys requires the below flag to be passed for copy (ctrl + c) to work
+[target.'cfg(all())']
-# https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
+rustflags = [
-# check status at https://developer.mozilla.org/en-US/docs/Web/API/Clipboard#browser_compatibility
+    # Global lints/warnings.
-# we don't use `[build]` because of rust analyzer's build cache invalidation https://github.com/emilk/eframe_template/issues/93
+    # See https://github.com/EmbarkStudios/rust-ecosystem/issues/22 for why we do this here
-[target.wasm32-unknown-unknown]
+    "-Dunsafe_code",
-rustflags = ["--cfg=web_sys_unstable_apis"]
+    "-Wclippy::all",
+    "-Wclippy::await_holding_lock",
+    "-Wclippy::char_lit_as_u8",
+    "-Wclippy::checked_conversions",
+    "-Wclippy::dbg_macro",
+    "-Wclippy::debug_assert_with_mut_call",
+    "-Wclippy::disallowed_methods",
+    "-Wclippy::doc_markdown",
+    "-Wclippy::empty_enum",
+    "-Wclippy::enum_glob_use",
+    "-Wclippy::equatable_if_let",
+    "-Wclippy::exit",
+    "-Wclippy::expl_impl_clone_on_copy",
+    "-Wclippy::explicit_deref_methods",
+    "-Wclippy::explicit_into_iter_loop",
+    "-Wclippy::fallible_impl_from",
+    "-Wclippy::filter_map_next",
+    "-Wclippy::flat_map_option",
+    "-Wclippy::float_cmp_const",
+    "-Wclippy::fn_params_excessive_bools",
+    "-Wclippy::from_iter_instead_of_collect",
+    "-Wclippy::if_let_mutex",
+    "-Wclippy::implicit_clone",
+    "-Wclippy::imprecise_flops",
+    "-Wclippy::inefficient_to_string",
+    "-Wclippy::invalid_upcast_comparisons",
+    "-Wclippy::iter_not_returning_iterator",
+    "-Wclippy::large_digit_groups",
+    "-Wclippy::large_stack_arrays",
+    "-Wclippy::large_types_passed_by_value",
+    "-Wclippy::let_unit_value",
+    "-Wclippy::linkedlist",
+    "-Wclippy::lossy_float_literal",
+    "-Wclippy::macro_use_imports",
+    "-Wclippy::manual_ok_or",
+    "-Wclippy::map_err_ignore",
+    "-Wclippy::map_flatten",
+    "-Wclippy::map_unwrap_or",
+    "-Wclippy::match_on_vec_items",
+    "-Wclippy::match_same_arms",
+    "-Wclippy::match_wild_err_arm",
+    "-Wclippy::match_wildcard_for_single_variants",
+    "-Wclippy::mem_forget",
+    "-Wclippy::mismatched_target_os",
+    "-Wclippy::missing_enforced_import_renames",
+    "-Wclippy::missing_errors_doc",
+    "-Wclippy::missing_safety_doc",
+    "-Wclippy::mut_mut",
+    "-Wclippy::mutex_integer",
+    "-Wclippy::needless_borrow",
+    "-Wclippy::needless_continue",
+    "-Wclippy::needless_for_each",
+    "-Wclippy::needless_pass_by_value",
+    "-Wclippy::option_option",
+    "-Wclippy::path_buf_push_overwrite",
+    "-Wclippy::ptr_as_ptr",
+    "-Wclippy::rc_mutex",
+    "-Wclippy::ref_option_ref",
+    "-Wclippy::rest_pat_in_fully_bound_structs",
+    "-Wclippy::same_functions_in_if_condition",
+    "-Wclippy::semicolon_if_nothing_returned",
+    "-Wclippy::single_match_else",
+    "-Wclippy::string_add_assign",
+    "-Wclippy::string_add",
+    "-Wclippy::string_lit_as_bytes",
+    "-Wclippy::string_to_string",
+    "-Wclippy::todo",
+    "-Wclippy::trait_duplication_in_bounds",
+    "-Wclippy::unimplemented",
+    "-Wclippy::unnested_or_patterns",
+    "-Wclippy::unused_self",
+    "-Wclippy::useless_transmute",
+    "-Wclippy::verbose_file_reads",
+    "-Wclippy::zero_sized_map_values",
+    "-Wfuture_incompatible",
+    "-Wnonstandard_style",
+    "-Wrust_2018_idioms",
+    "-Wrustdoc::missing_crate_level_docs",
+]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,7 +8,7 @@ assignees: ''
 ---
 
 <!--
-First look if there is already a similar bug report. If there is, upvote the issue with 👍
+First look if there is already a similar bug report. If there is, add a comment to it instead!
 
 Please also check if the bug is still present in latest master! Do so by adding the following lines to your Cargo.toml:
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -8,7 +8,7 @@ assignees: ''
 ---
 
 <!--
-First look if there is already a similar feature request. If there is, upvote the issue with 👍
+First look if there is already a similar feature request. If there is, add a comment to it instead!
 -->
 
 

.github/workflows/rust.yml

@@ -3,209 +3,195 @@ on: [push, pull_request]
 name: CI
 
 env:
-  # web_sys_unstable_apis is required to enable the web_sys clipboard API which eframe web uses,
+  # This is required to enable the web_sys clipboard API which eframe web uses
-  # as well as by the wasm32-backend of the wgpu crate.
   # https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Clipboard.html
   # https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
   RUSTFLAGS: --cfg=web_sys_unstable_apis -D warnings
   RUSTDOCFLAGS: -D warnings
 
 jobs:
-  fmt-crank-check-test:
+  check_default:
-    name: Format + check + test
+    name: cargo check (default features)
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: default
-          toolchain: 1.65.0
-          override: true
-
-      - name: Install packages (Linux)
-        if: runner.os == 'Linux'
-        #uses: awalsh128/cache-apt-pkgs-action@v1.2.2
-        #TODO(emilk) use upstream when https://github.com/awalsh128/cache-apt-pkgs-action/pull/90 is merged
-        uses: rerun-io/cache-apt-pkgs-action@59534850182063abf1b2c11bb3686722a12a8397
-        with:
-          packages: libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev libgtk-3-dev # libgtk-3-dev is used by rfd
-          version: 1.0
-          execute_install_scripts: true
-
-      - name: Set up cargo cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: Rustfmt
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Install cargo-cranky
-        uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-cranky
-
-      - name: check --all-features
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --locked --all-features --all-targets
-
-      - name: check default features
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --locked --all-targets
-
-      - name: check --no-default-features
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --locked --no-default-features --lib --all-targets
-
-      - name: check eframe --no-default-features
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --locked --no-default-features --lib --all-targets -p eframe
-
-      - name: Test doc-tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --doc --all-features
-
-      - name: cargo doc --lib
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --lib --no-deps --all-features
-
-      - name: cargo doc --document-private-items
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --document-private-items --no-deps --all-features
-
-      - name: Test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all-features
-
-      - name: Cranky
-        uses: actions-rs/cargo@v1
-        with:
-          command: cranky
-          args: --all-targets --all-features -- -D warnings
-
-  # ---------------------------------------------------------------------------
-
-  check_wasm:
-    name: Check wasm32 + wasm-bindgen
-    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.65.0
+          toolchain: 1.60.0
-          target: wasm32-unknown-unknown
           override: true
-
+      - name: Install packages (Linux)
-      - run: sudo apt-get update && sudo apt-get install libgtk-3-dev
+        if: runner.os == 'Linux'
-
+        run: sudo apt-get update && sudo apt-get install libspeechd-dev libgtk-3-dev
-      - name: Set up cargo cache
+      - uses: actions-rs/cargo@v1
-        uses: Swatinem/rust-cache@v2
-
-      - name: Install cargo-cranky
-        uses: baptiste0928/cargo-install@v1
         with:
-          crate: cargo-cranky
+          command: check
+          args: --locked
 
-      - name: Check wasm32 egui_demo_app
+  check_all_features:
-        uses: actions-rs/cargo@v1
+    name: cargo check --all-features
+    strategy:
+      matrix:
+        os: [ubuntu-20.04, windows-latest, macOS-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - name: Install packages (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install libspeechd-dev libgtk-3-dev
+      - uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all-features
+
+  check_web_default:
+    name: cargo check web (default features)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - run: rustup target add wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
         with:
           command: check
           args: -p egui_demo_app --lib --target wasm32-unknown-unknown
 
-      - name: Check wasm32 egui_demo_app --all-features
+  check_egui_demo_app:
-        uses: actions-rs/cargo@v1
+    name: cargo check -p egui_demo_app
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - name: check
+        run: cargo check -p egui_demo_app
+
+  check_wasm_eframe_with_features:
+    name: cargo check wasm eframe
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - run: rustup target add wasm32-unknown-unknown
+      - name: check
+        run: cargo check -p eframe --lib --no-default-features --features glow,persistence --target wasm32-unknown-unknown
+
+  check_web_all_features:
+    name: cargo check web --all-features
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - run: rustup target add wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
         with:
           command: check
           args: -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
 
-      - name: Check wasm32 eframe
+  test:
-        uses: actions-rs/cargo@v1
+    name: cargo test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          command: check
+          profile: minimal
-          args: -p eframe --lib --no-default-features --features glow,persistence --target wasm32-unknown-unknown
+          toolchain: 1.60.0
-
+          override: true
-      - name: wasm-bindgen
+      - name: Install packages (Linux)
-        uses: jetli/wasm-bindgen-action@v0.1.0
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libspeechd-dev libxkbcommon-dev libssl-dev libgtk-3-dev # libgtk-3-dev is used by rfd
+      - uses: actions-rs/cargo@v1
         with:
-          version: "0.2.84"
+          command: test
+          args: --all-features
 
-      - run: ./sh/wasm_bindgen_check.sh --skip-setup
+  fmt:
-
+    name: cargo fmt
-      - name: Cranky wasm32
+    runs-on: ubuntu-latest
-        uses: actions-rs/cargo@v1
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          command: cranky
+          profile: minimal
-          args: --target wasm32-unknown-unknown --all-features -p egui_demo_app --lib -- -D warnings
+          toolchain: 1.60.0
+          override: true
+      - run: rustup component add rustfmt
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
 
-  # ---------------------------------------------------------------------------
+  clippy:
+    name: cargo clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - run: rustup component add clippy
+      - name: Install packages (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install libspeechd-dev libgtk-3-dev # libgtk-3-dev is used by rfd
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --workspace --all-targets --all-features --  -D warnings -W clippy::all
+
+  doc:
+    name: cargo doc
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.60.0
+          override: true
+      - name: Install packages (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install libspeechd-dev
+      - run: cargo doc --lib --no-deps --all-features
 
   cargo-deny:
-    name: cargo deny
+    runs-on: ubuntu-20.04
-    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v2
       - uses: EmbarkStudios/cargo-deny-action@v1
-        with:
-          rust-version: "1.65.0"
 
-  # ---------------------------------------------------------------------------
+  wasm_bindgen:
-
+    name: wasm-bindgen
-  android:
+    runs-on: ubuntu-latest
-    name: android
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: 1.65.0
-          target: aarch64-linux-android
-          override: true
-
-      - name: Set up cargo cache
-        uses: Swatinem/rust-cache@v2
-
-      - run: cargo check --features wgpu --target aarch64-linux-android
-        working-directory: crates/eframe
-
-  # ---------------------------------------------------------------------------
-
-  windows:
-    name: Check Windows
-    runs-on: windows-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.65.0
+          toolchain: 1.60.0
           override: true
-
+      - run: rustup target add wasm32-unknown-unknown
-      - name: Set up cargo cache
+      - run: cargo install wasm-bindgen-cli
-        uses: Swatinem/rust-cache@v2
+      - run: ./sh/wasm_bindgen_check.sh
-
-      - name: Check
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all-targets --all-features

.gitignore

@@ -1,7 +1,4 @@
-.DS_Store
 **/target
-**/target_ra
-**/target_wasm
 /.*.json
 /.vscode
 /media/*

.vscode/settings.json

@@ -1,32 +1,5 @@
 {
     "files.insertFinalNewline": true,
     "editor.formatOnSave": true,
-    "files.trimTrailingWhitespace": true,
+    "files.trimTrailingWhitespace": true
-    "editor.semanticTokenColorCustomizations": {
-        "rules": {
-            "*.unsafe:rust": "#eb5046"
-        }
-    },
-    "files.exclude": {
-        "target/**": true,
-        "target_ra/**": true,
-    },
-    // Tell Rust Analyzer to use its own target directory, so we don't need to wait for it to finish wen we want to `cargo run`
-    "rust-analyzer.checkOnSave.overrideCommand": [
-        "cargo",
-        "cranky",
-        "--target-dir=target_ra",
-        "--workspace",
-        "--message-format=json",
-        "--all-targets"
-    ],
-    "rust-analyzer.cargo.buildScripts.overrideCommand": [
-        "cargo",
-        "check",
-        "--quiet",
-        "--target-dir=target_ra",
-        "--workspace",
-        "--message-format=json",
-        "--all-targets"
-    ],
 }

ARCHITECTURE.md

@@ -1,4 +1,4 @@
-# Architecture
+# Arcitecture
 This document describes how the crates that make up egui are all connected.
 
 Also see [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md) for what to do before opening a PR.

CHANGELOG.md

@@ -1,151 +1,26 @@
 # egui changelog
 All notable changes to the `egui` crate will be documented in this file.
 
-NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG.md), [`egui-winit`](crates/egui-winit/CHANGELOG.md), [`egui_glium`](crates/egui_glium/CHANGELOG.md), [`egui_glow`](crates/egui_glow/CHANGELOG.md) and [`egui-wgpu`](crates/egui-wgpu/CHANGELOG.md) have their own changelogs!
+NOTE: [`epaint`](epaint/CHANGELOG.md), [`eframe`](eframe/CHANGELOG.md), [`egui-winit`](egui-winit/CHANGELOG.md), [`egui_glium`](egui_glium/CHANGELOG.md), and [`egui_glow`](egui_glow/CHANGELOG.md) have their own changelogs!
 
 
 ## Unreleased
-
-
-## 0.21.0 - 2023-02-08 - Deadlock fix and style customizability
-* ⚠️ BREAKING: `egui::Context` now use closures for locking ([#2625](https://github.com/emilk/egui/pull/2625)):
-  * `ctx.input().key_pressed(Key::A)` -> `ctx.input(|i| i.key_pressed(Key::A))`
-  * `ui.memory().toggle_popup(popup_id)` -> `ui.memory_mut(|mem| mem.toggle_popup(popup_id))`
-
-### Added ⭐
-* Add `Response::drag_started_by` and `Response::drag_released_by` for convenience, similar to `dragged` and `dragged_by` ([#2507](https://github.com/emilk/egui/pull/2507)).
-* Add `PointerState::*_pressed` to check if the given button was pressed in this frame ([#2507](https://github.com/emilk/egui/pull/2507)).
-* `Event::Key` now has a `repeat` field that is set to `true` if the event was the result of a key-repeat ([#2435](https://github.com/emilk/egui/pull/2435)).
-* Add `Slider::drag_value_speed`, which lets you ask for finer precision when dragging the slider value rather than the actual slider.
-* Add `Memory::any_popup_open`, which returns true if any popup is currently open ([#2464](https://github.com/emilk/egui/pull/2464)).
-* Add `Plot::clamp_grid` to only show grid where there is data ([#2480](https://github.com/emilk/egui/pull/2480)).
-* Add `ScrollArea::drag_to_scroll` if you want to turn off that feature.
-* Add `Response::on_hover_and_drag_cursor`.
-* Add `Window::default_open` ([#2539](https://github.com/emilk/egui/pull/2539)).
-* Add `ProgressBar::fill` if you want to set the fill color manually. ([#2618](https://github.com/emilk/egui/pull/2618)).
-* Add `Button::rounding` to enable round buttons ([#2616](https://github.com/emilk/egui/pull/2616)).
-* Add `WidgetVisuals::optional_bg_color` - set it to `Color32::TRANSPARENT` to hide button backgrounds ([#2621](https://github.com/emilk/egui/pull/2621)).
-* Add `Context::screen_rect` and `Context::set_cursor_icon` ([#2625](https://github.com/emilk/egui/pull/2625)).
-* You can turn off the vertical line left of indented regions with `Visuals::indent_has_left_vline` ([#2636](https://github.com/emilk/egui/pull/2636)).
-* Add `Response.highlight` to highlight a widget ([#2632](https://github.com/emilk/egui/pull/2632)).
-* Add `Separator::grow` and `Separator::shrink` ([#2665](https://github.com/emilk/egui/pull/2665)).
-* Add `Slider::trailing_fill` for trailing color behind the circle like a `ProgressBar` ([#2660](https://github.com/emilk/egui/pull/2660)).
-
-### Changed 🔧
-* Improved plot grid appearance ([#2412](https://github.com/emilk/egui/pull/2412)).
-* Improved the algorithm for picking the number of decimals to show when hovering values in the `Plot`.
-* Default `ComboBox` is now controlled with `Spacing::combo_width` ([#2621](https://github.com/emilk/egui/pull/2621)).
-* `DragValue` and `Slider` now use the proportional font ([#2638](https://github.com/emilk/egui/pull/2638)).
-* `ScrollArea` is less aggressive about clipping its contents ([#2665](https://github.com/emilk/egui/pull/2665)).
-* Updated to be compatible with a major breaking change in AccessKit that drastically reduces memory usage when accessibility is enabled ([#2678](https://github.com/emilk/egui/pull/2678)).
-* Improve `DragValue` behavior ([#2649](https://github.com/emilk/egui/pull/2649), [#2650](https://github.com/emilk/egui/pull/2650), [#2688](https://github.com/emilk/egui/pull/2688), [#2638](https://github.com/emilk/egui/pull/2638)).
-
-### Fixed 🐛
-* Trigger `PointerEvent::Released` for drags ([#2507](https://github.com/emilk/egui/pull/2507)).
-* Expose `TextEdit`'s multiline flag to AccessKit ([#2448](https://github.com/emilk/egui/pull/2448)).
-* Don't render `\r` (Carriage Return) ([#2452](https://github.com/emilk/egui/pull/2452)).
-* The `button_padding` style option works closer as expected with image+text buttons now ([#2510](https://github.com/emilk/egui/pull/2510)).
-* Menus are now moved to fit on the screen.
-* Fix `Window::pivot` causing windows to move around ([#2694](https://github.com/emilk/egui/pull/2694)).
-
-
-## 0.20.1 - 2022-12-11 - Fix key-repeat
-### Changed 🔧
-* `InputState`: all press functions again include key repeats (like in egui 0.19) ([#2429](https://github.com/emilk/egui/pull/2429)).
-* Improve the look of thin white lines ([#2437](https://github.com/emilk/egui/pull/2437)).
-
-### Fixed 🐛
-* Fix key-repeats for `TextEdit`, `Slider`s, etc ([#2429](https://github.com/emilk/egui/pull/2429)).
-
-
-## 0.20.0 - 2022-12-08 - AccessKit, prettier text, overlapping widgets
-* MSRV (Minimum Supported Rust Version) is now `1.65.0` ([#2314](https://github.com/emilk/egui/pull/2314)).
-* ⚠️ BREAKING: egui now expects integrations to do all color blending in gamma space ([#2071](https://github.com/emilk/egui/pull/2071)).
-* ⚠️ BREAKING: if you have overlapping interactive widgets, only the top widget (last added) will be interactive ([#2244](https://github.com/emilk/egui/pull/2244)).
-
-### Added ⭐
-* Added helper functions for animating panels that collapse/expand ([#2190](https://github.com/emilk/egui/pull/2190)).
-* Added `Context::os/Context::set_os` to query/set what operating system egui believes it is running on ([#2202](https://github.com/emilk/egui/pull/2202)).
-* Added `Button::shortcut_text` for showing keyboard shortcuts in menu buttons ([#2202](https://github.com/emilk/egui/pull/2202)).
-* Added `egui::KeyboardShortcut` for showing keyboard shortcuts in menu buttons ([#2202](https://github.com/emilk/egui/pull/2202)).
-* Texture loading now takes a `TexureOptions` with minification and magnification filters ([#2224](https://github.com/emilk/egui/pull/2224)).
-* Added `Key::Minus` and `Key::Equals` ([#2239](https://github.com/emilk/egui/pull/2239)).
-* Added `egui::gui_zoom` module with helpers for scaling the whole GUI of an app ([#2239](https://github.com/emilk/egui/pull/2239)).
-* You can now put one interactive widget on top of another, and only one will get interaction at a time ([#2244](https://github.com/emilk/egui/pull/2244)).
-* Added `spacing.menu_margin` for customizing menu spacing ([#2036](https://github.com/emilk/egui/pull/2036))
-* Added possibility to enable text wrap for the selected text of `egui::ComboBox` ([#2272](https://github.com/emilk/egui/pull/2272))
-* Added `Area::constrain` and `Window::constrain` which constrains area to the screen bounds ([#2270](https://github.com/emilk/egui/pull/2270)).
-* Added `Area::pivot` and `Window::pivot` which controls what part of the window to position ([#2303](https://github.com/emilk/egui/pull/2303)).
-* Added support for [thin space](https://en.wikipedia.org/wiki/Thin_space).
-* Added optional integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
-* Added `panel_fill`, `window_fill` and `window_stroke` to `Visuals` for your theming pleasure ([#2406](https://github.com/emilk/egui/pull/2406)).
-* Plots:
-  * Allow linking plot cursors ([#1722](https://github.com/emilk/egui/pull/1722)).
-  * Added `Plot::auto_bounds_x/y` and `Plot::reset` ([#2029](https://github.com/emilk/egui/pull/2029)).
-  * Added `PlotUi::translate_bounds` ([#2145](https://github.com/emilk/egui/pull/2145)).
-  * Added `PlotUi::set_plot_bounds` ([#2320](https://github.com/emilk/egui/pull/2320)).
-  * Added `PlotUi::plot_secondary_clicked` ([#2318](https://github.com/emilk/egui/pull/2318)).
-
-### Changed 🔧
-* Panels always have a separator line, but no stroke on other sides. Their spacing has also changed slightly ([#2261](https://github.com/emilk/egui/pull/2261)).
-* Tooltips are only shown when mouse pointer is still ([#2263](https://github.com/emilk/egui/pull/2263)).
-* Make it slightly easier to click buttons ([#2304](https://github.com/emilk/egui/pull/2304)).
-* `egui::color` has been renamed `egui::ecolor` ([#2399](https://github.com/emilk/egui/pull/2399)).
-
-### Fixed 🐛
-* ⚠️ BREAKING: Fix text being too small ([#2069](https://github.com/emilk/egui/pull/2069)).
-* Improve mixed CJK/Latin line-breaking ([#1986](https://github.com/emilk/egui/pull/1986)).
-* Improved text rendering ([#2071](https://github.com/emilk/egui/pull/2071)).
-* Constrain menu popups to the screen ([#2191](https://github.com/emilk/egui/pull/2191)).
-* Less jitter when calling `Context::set_pixels_per_point` ([#2239](https://github.com/emilk/egui/pull/2239)).
-* Fixed popups and color edit going outside the screen.
-* Fixed keyboard support in `DragValue` ([#2342](https://github.com/emilk/egui/pull/2342)).
-* If you nest `ScrollAreas` inside each other, the inner area will now move its scroll bar so it is always visible ([#2371](https://github.com/emilk/egui/pull/2371)).
-* Ignore key-repeats for `input.key_pressed` ([#2334](https://github.com/emilk/egui/pull/2334), [#2389](https://github.com/emilk/egui/pull/2389)).
-* Fixed issue with calling `set_pixels_per_point` each frame ([#2352](https://github.com/emilk/egui/pull/2352)).
-* Fix bug in `ScrollArea::show_rows` ([#2258](https://github.com/emilk/egui/pull/2258)).
-* Fix bug in `plot::Line::fill` ([#2275](https://github.com/emilk/egui/pull/2275)).
-* Only emit `changed` events in `radio_value` and `selectable_value` if the value actually changed ([#2343](https://github.com/emilk/egui/pull/2343)).
-* Fixed sizing bug in `Grid` ([#2384](https://github.com/emilk/egui/pull/2384)).
-* `ComboBox::width` now correctly sets the outer width ([#2406](https://github.com/emilk/egui/pull/2406)).
-
-
-## 0.19.0 - 2022-08-20
 ### Added ⭐
 * Added `*_released` & `*_clicked` methods for `PointerState` ([#1582](https://github.com/emilk/egui/pull/1582)).
-* Added `PointerButton::Extra1` and `PointerButton::Extra2` ([#1592](https://github.com/emilk/egui/pull/1592)).
 * Added `egui::hex_color!` to create `Color32`'s from hex strings under the `color-hex` feature ([#1596](https://github.com/emilk/egui/pull/1596)).
 * Optimized painting of filled circles (e.g. for scatter plots) by 10x or more ([#1616](https://github.com/emilk/egui/pull/1616)).
 * Added opt-in feature `deadlock_detection` to detect double-lock of mutexes on the same thread ([#1619](https://github.com/emilk/egui/pull/1619)).
 * Added `InputState::stable_dt`: a more stable estimate for the delta-time in reactive mode ([#1625](https://github.com/emilk/egui/pull/1625)).
 * You can now specify a texture filter for your textures ([#1636](https://github.com/emilk/egui/pull/1636)).
-* Added functions keys in `egui::Key` ([#1665](https://github.com/emilk/egui/pull/1665)).
+* Added support for using `PaintCallback` shapes with the WGPU backend ([#1684](https://github.com/emilk/egui/pull/1684))
-* Added support for using `PaintCallback` shapes with the WGPU backend ([#1684](https://github.com/emilk/egui/pull/1684)).
-* Added `Context::request_repaint_after` ([#1694](https://github.com/emilk/egui/pull/1694)).
-* `ctrl-h` now acts like backspace in `TextEdit` ([#1812](https://github.com/emilk/egui/pull/1812)).
-* Added `custom_formatter` method for `Slider` and `DragValue` ([#1851](https://github.com/emilk/egui/issues/1851)).
-* Added `RawInput::has_focus` which backends can set to indicate whether the UI as a whole has the keyboard focus ([#1859](https://github.com/emilk/egui/pull/1859)).
-* Added `PointerState::button_double_clicked()` and `PointerState::button_triple_clicked()` ([#1906](https://github.com/emilk/egui/issues/1906)).
-* Added `custom_formatter`, `binary`, `octal`, and `hexadecimal` to `DragValue` and `Slider` ([#1953](https://github.com/emilk/egui/issues/1953))
 
-### Changed 🔧
+### Changed
-* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* `PaintCallback` shapes now require the whole callback to be put in an `Arc<dyn Any>` with the value being a backend-specific callback type. ([#1684](https://github.com/emilk/egui/pull/1684))
-* `PaintCallback` shapes now require the whole callback to be put in an `Arc<dyn Any>` with the value being a backend-specific callback type ([#1684](https://github.com/emilk/egui/pull/1684)).
+* Replaced `needs_repaint` in `FullOutput` with `repaint_after`. Used to force repaint after the set duration in reactive mode.([#1694](https://github.com/emilk/egui/pull/1694)).
-* Replaced `needs_repaint` in `FullOutput` with `repaint_after`. Used to force repaint after the set duration in reactive mode ([#1694](https://github.com/emilk/egui/pull/1694)).
-* `Layout::left_to_right` and `Layout::right_to_left` now takes the vertical align as an argument. Previous default was `Align::Center`.
-* Improved ergonomics of adding plot items. All plot items that take a series of 2D coordinates can now be created directly from `Vec<[f64; 2]>`. The `Value` and `Values` types were removed in favor of `PlotPoint` and `PlotPoints` respectively ([#1816](https://github.com/emilk/egui/pull/1816)).
-* `TextBuffer` no longer needs to implement `AsRef<str>` ([#1824](https://github.com/emilk/egui/pull/1824)).
 
 ### Fixed 🐛
-* Fixed `Response::changed` for `ui.toggle_value` ([#1573](https://github.com/emilk/egui/pull/1573)).
 * Fixed `ImageButton`'s changing background padding on hover ([#1595](https://github.com/emilk/egui/pull/1595)).
-* Fixed `Plot` auto-bounds bug ([#1599](https://github.com/emilk/egui/pull/1599)).
+* Fix dead-lock when alt-tabbing while also showing a tooltip ([#1618](https://github.com/emilk/egui/pull/1618)).
-* Fixed dead-lock when alt-tabbing while also showing a tooltip ([#1618](https://github.com/emilk/egui/pull/1618)).
-* Fixed `ScrollArea` scrolling when editing an unrelated `TextEdit` ([#1779](https://github.com/emilk/egui/pull/1779)).
-* Fixed `Slider` not always generating events on change ([#1854](https://github.com/emilk/egui/pull/1854)).
-* Fixed jitter of anchored windows for the first frame ([#1856](https://github.com/emilk/egui/pull/1856)).
-* Fixed focus behavior when pressing Tab in a UI with no focused widget ([#1861](https://github.com/emilk/egui/pull/1861)).
-* Fixed automatic plot bounds ([#1865](https://github.com/emilk/egui/pull/1865)).
 
 
 ## 0.18.1 - 2022-05-01
@@ -177,7 +52,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * `ClippedMesh` has been replaced with `ClippedPrimitive` ([#1351](https://github.com/emilk/egui/pull/1351)).
 * Renamed `Frame::margin` to `Frame::inner_margin`.
 * Renamed `AlphaImage` to `FontImage` to discourage any other use for it ([#1412](https://github.com/emilk/egui/pull/1412)).
-* Warnings will be painted on screen when there is an `Id` clash for `Grid`, `Plot` or `ScrollArea` ([#1452](https://github.com/emilk/egui/pull/1452)).
+* Warnings will pe painted on screen when there is an `Id` clash for `Grid`, `Plot` or `ScrollArea` ([#1452](https://github.com/emilk/egui/pull/1452)).
 * `Checkbox` and `RadioButton` with an empty label (`""`) will now take up much less space ([#1456](https://github.com/emilk/egui/pull/1456)).
 * Replaced `Memory::top_most_layer` with more flexible `Memory::layer_ids`.
 * Renamed the feature `convert_bytemuck` to `bytemuck` ([#1467](https://github.com/emilk/egui/pull/1467)).
@@ -188,9 +63,9 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Fixed `ComboBox`es always being rendered left-aligned ([#1304](https://github.com/emilk/egui/pull/1304)).
 * Fixed ui code that could lead to a deadlock ([#1380](https://github.com/emilk/egui/pull/1380)).
 * Text is darker and more readable in bright mode ([#1412](https://github.com/emilk/egui/pull/1412)).
-* Fixed a lot of broken/missing doclinks  ([#1419](https://github.com/emilk/egui/pull/1419)).
+* Fix a lot of broken/missing doclinks  ([#1419](https://github.com/emilk/egui/pull/1419)).
 * Fixed `Ui::add_visible` sometimes leaving the `Ui` in a disabled state ([#1436](https://github.com/emilk/egui/issues/1436)).
-* Added line breaking rules for Japanese text ([#1498](https://github.com/emilk/egui/pull/1498)).
+* Add line breaking rules for Japanese text ([#1498](https://github.com/emilk/egui/pull/1498)).
 
 ### Deprecated ☢️
 * Deprecated `CollapsingHeader::selectable` ([#1538](https://github.com/emilk/egui/pull/1538)).
@@ -326,7 +201,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 ## 0.16.1 - 2021-12-31 - Add back `CtxRef::begin_frame,end_frame`
 
 ### Added ⭐
-* Added back `CtxRef::begin_frame,end_frame` as an alternative to `CtxRef::run`.
+* Add back `CtxRef::begin_frame,end_frame` as an alternative to `CtxRef::run`.
 
 
 ## 0.16.0 - 2021-12-29 - Context menus and rich text
@@ -385,15 +260,15 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 <img src="media/egui-0.15-code-editor.gif">
 
 ### Added ⭐
-* Added horizontal scrolling support to `ScrollArea` and `Window` (opt-in).
+* Add horizontal scrolling support to `ScrollArea` and `Window` (opt-in).
 * `TextEdit::layouter`: Add custom text layout for e.g. syntax highlighting or WYSIWYG.
 * `Fonts::layout_job`: New text layout engine allowing mixing fonts, colors and styles, with underlining and strikethrough.
-* Added `ui.add_enabled(bool, widget)` to easily add a possibly disabled widget.
+* Add `ui.add_enabled(bool, widget)` to easily add a possibly disabled widget.
-* Added `ui.add_enabled_ui(bool, |ui| …)` to create a possibly disabled UI section.
+* Add `ui.add_enabled_ui(bool, |ui| …)` to create a possibly disabled UI section.
-* Added feature `"serialize"` separatedly from `"persistence"`.
+* Add feature `"serialize"` separatedly from `"persistence"`.
-* Added `egui::widgets::global_dark_light_mode_buttons` to easily add buttons for switching the egui theme.
+* Add `egui::widgets::global_dark_light_mode_buttons` to easily add buttons for switching the egui theme.
 * `TextEdit` can now be used to show text which can be selected and copied, but not edited.
-* Added `Memory::caches` for caching things from one frame to the next.
+* Add `Memory::caches` for caching things from one frame to the next.
 
 ### Changed 🔧
 * Change the default monospace font to [Hack](https://github.com/source-foundry/Hack).
@@ -407,14 +282,14 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Smaller and nicer color picker.
 * `ScrollArea` will auto-shrink to content size unless told otherwise using `ScollArea::auto_shrink`.
 * By default, `Slider`'s `clamp_to_range` is set to true.
-* Renamed `TextEdit::enabled` to `TextEdit::interactive`.
+* Rename `TextEdit::enabled` to `TextEdit::interactive`.
 * `ui.label` (and friends) now take `impl ToString` as argument instead of `impl Into<Label>`.
 
 ### Fixed 🐛
-* Fixed wrongly sized multiline `TextEdit` in justified layouts.
+* Fix wrongly sized multiline `TextEdit` in justified layouts.
-* Fixed clip rectangle of windows that don't fit the central area.
+* Fix clip rectangle of windows that don't fit the central area.
 * Show tooltips above widgets on touch screens.
-* Fixed popups sometimes getting clipped by panels.
+* Fix popups sometimes getting clipped by panels.
 
 ### Removed 🔥
 * Replace `Button::enabled` with `ui.add_enabled`.
@@ -439,20 +314,20 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 ## 0.14.2 - 2021-08-28 - Window resize fix
 
 ### Fixed 🐛
-* Fixed window resize bug introduced in `0.14.1`.
+* Fix window resize bug introduced in `0.14.1`.
 
 
 ## 0.14.1 - 2021-08-28 - Layout bug fixes
 
 ### Added ⭐
-* Added `Ui::horizontal_top`.
+* Add `Ui::horizontal_top`.
 
 ### Fixed 🐛
-* Fixed `set_width/set_min_width/set_height/set_min_height/expand_to_include_x/expand_to_include_y`.
+* Fix `set_width/set_min_width/set_height/set_min_height/expand_to_include_x/expand_to_include_y`.
 * Make minimum grid column width propagate properly.
 * Make sure `TextEdit` contents expand to fill width if applicable.
 * `ProgressBar`: add a minimum width and fix for having it in an infinite layout.
-* Fixed sometimes not being able to click inside a combo box or popup menu.
+* Fix sometimes not being able to click inside a combo box or popup menu.
 
 
 ## 0.14.0 - 2021-08-24 - Ui panels and bug fixes
@@ -461,10 +336,10 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Panels can now be added to any `Ui`.
 * Plot:
   * [Line styles](https://github.com/emilk/egui/pull/482).
-  * Added `show_background` and `show_axes` methods to `Plot`.
+  * Add `show_background` and `show_axes` methods to `Plot`.
 * [Progress bar](https://github.com/emilk/egui/pull/519).
 * `Grid::num_columns`: allow the last column to take up the rest of the space of the parent `Ui`.
-* Added an API for dropping files into egui (see `RawInput`).
+* Add an API for dropping files into egui (see `RawInput`).
 * `CollapsingHeader` can now optionally be selectable.
 
 ### Changed 🔧
@@ -474,12 +349,12 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Tooltips are now moved to not cover the widget they are attached to.
 
 ### Fixed 🐛
-* Fixed custom font definitions getting replaced when `pixels_per_point` is changed.
+* Fix custom font definitions getting replaced when `pixels_per_point` is changed.
-* Fixed `lost_focus` for `TextEdit`.
+* Fix `lost_focus` for `TextEdit`.
 * Clicking the edge of a menu button will now properly open the menu.
-* Fixed hover detection close to an `Area`.
+* Fix hover detection close to an `Area`.
-* Fixed case where `Plot`'s `min_auto_bounds` could be ignored after the first call to `Plot::ui`.
+* Fix case where `Plot`'s `min_auto_bounds` could be ignored after the first call to `Plot::ui`.
-* Fixed slow startup when using large font files.
+* Fix slow startup when using large font files.
 
 ### Contributors 🙏
 * [barrowsys](https://github.com/barrowsys)
@@ -511,19 +386,19 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
   * [Plot legend improvements](https://github.com/emilk/egui/pull/410).
   * [Line markers for plots](https://github.com/emilk/egui/pull/363).
 * Panels:
-  * Added right and bottom panels (`SidePanel::right` and `Panel::bottom`).
+  * Add right and bottom panels (`SidePanel::right` and `Panel::bottom`).
   * Panels can now be resized.
-  * Added an option to overwrite frame of a `Panel`.
+  * Add an option to overwrite frame of a `Panel`.
 * [Improve accessibility / screen reader](https://github.com/emilk/egui/pull/412).
-* Added `ScrollArea::show_rows` for efficient scrolling of huge UI:s.
+* Add `ScrollArea::show_rows` for efficient scrolling of huge UI:s.
-* Added `ScrollArea::enable_scrolling` to allow freezing scrolling when editing TextEdit widgets within it
+* Add `ScrollArea::enable_scrolling` to allow freezing scrolling when editing TextEdit widgets within it
-* Added `Ui::set_visible` as a way to hide widgets.
+* Add `Ui::set_visible` as a way to hide widgets.
-* Added `Style::override_text_style` to easily change the text style of everything in a `Ui` (or globally).
+* Add `Style::override_text_style` to easily change the text style of everything in a `Ui` (or globally).
 * You can now change `TextStyle` on checkboxes, radio buttons and `SelectableLabel`.
-* Added support for [cint](https://crates.io/crates/cint) under `cint` feature.
+* Add support for [cint](https://crates.io/crates/cint) under `cint` feature.
-* Added features `extra_asserts` and `extra_debug_asserts` to enable additional checks.
+* Add features `extra_asserts` and `extra_debug_asserts` to enable additional checks.
 * `TextEdit` now supports edits on a generic buffer using `TextBuffer`.
-* Added `Context::set_debug_on_hover` and `egui::trace!(ui)`
+* Add `Context::set_debug_on_hover` and `egui::trace!(ui)`
 
 ### Changed 🔧
 * Minimum Rust version is now 1.51 (used to be 1.52)
@@ -534,36 +409,36 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * `SidePanel::left` is resizable by default.
 
 ### Fixed 🐛
-* Fixed uneven lettering on non-integral device scales ("extortion lettering").
+* Fix uneven lettering on non-integral device scales ("extortion lettering").
-* Fixed invisible scroll bar when native window is too narrow for egui.
+* Fix invisible scroll bar when native window is too narrow for egui.
 
 
 ## 0.12.0 - 2021-05-10 - Multitouch, user memory, window pivots, and improved plots
 
 ### Added ⭐
-* Added anchors to windows and areas so you can put a window in e.g. the top right corner.
+* Add anchors to windows and areas so you can put a window in e.g. the top right corner.
 * Make labels interactive with `Label::sense(Sense::click())`.
-* Added `Response::request_focus` and `Response::surrender_focus`.
+* Add `Response::request_focus` and `Response::surrender_focus`.
-* Added `TextEdit::code_editor` (VERY basic).
+* Add `TextEdit::code_editor` (VERY basic).
 * [Pan and zoom plots](https://github.com/emilk/egui/pull/317).
 * [Add plot legends](https://github.com/emilk/egui/pull/349).
 * [Users can now store custom state in `egui::Memory`](https://github.com/emilk/egui/pull/257).
-* Added `Response::on_disabled_hover_text` to show tooltip for disabled widgets.
+* Add `Response::on_disabled_hover_text` to show tooltip for disabled widgets.
 * Zoom input: ctrl-scroll and (on `eframe` web) trackpad-pinch gesture.
 * Support for raw [multi touch](https://github.com/emilk/egui/pull/306) events,
   enabling zoom, rotate, and more. Works with `eframe` web on mobile devices,
   and should work with `egui_glium` for certain touch devices/screens.
-* Added (optional) compatibility with [mint](https://docs.rs/mint).
+* Add (optional) compatibility with [mint](https://docs.rs/mint).
 
 ### Changed 🔧
 * Make `Memory::has_focus` public (again).
 * `Plot` must now be given a name that is unique within its scope.
 * Tab only selects labels if the `screen_reader` option is turned on.
-* Renamed `ui.wrap` to `ui.scope`.
+* Rename `ui.wrap` to `ui.scope`.
 
 ### Fixed 🐛
-* Fixed [defocus-bug on touch screens](https://github.com/emilk/egui/issues/288).
+* Fix [defocus-bug on touch screens](https://github.com/emilk/egui/issues/288).
-* Fixed bug with the layout of wide `DragValue`s.
+* Fix bug with the layout of wide `DragValue`s.
 
 ### Removed 🔥
 * Moved experimental markup language to `egui_demo_lib`
@@ -577,24 +452,24 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
   * Use arrow keys to adjust sliders and `DragValue`s.
 * egui will now output events when widgets gain keyboard focus.
   * This can be hooked up to a screen reader to aid the visually impaired
-* Added the option to restrict the dragging bounds of `Window` and `Area` to a specified area using `drag_bounds(rect)`.
+* Add the option to restrict the dragging bounds of `Window` and `Area` to a specified area using `drag_bounds(rect)`.
-* Added support for small and raised text.
+* Add support for small and raised text.
-* Added `ui.set_row_height`.
+* Add `ui.set_row_height`.
-* Added `DebugOptions::show_widgets` to debug layouting by hovering widgets.
+* Add `DebugOptions::show_widgets` to debug layouting by hovering widgets.
-* Added `ComboBox` to more easily customize combo boxes.
+* Add `ComboBox` to more easily customize combo boxes.
-* Added `Slider::new` and `DragValue::new` to replace old type-specific constructors.
+* Add `Slider::new` and `DragValue::new` to replace old type-specific constructors.
-* Added `TextEdit::password` to hide input characters.
+* Add `TextEdit::password` to hide input characters.
 
 ### Changed 🔧
 * `ui.advance_cursor` is now called `ui.add_space`.
 * `kb_focus` is now just called `focus`.
 
 ### Fixed 🐛
-* Fixed some bugs related to centered layouts.
+* Fix some bugs related to centered layouts.
 * Fixed secondary-click to open a menu.
 * [Fix panic for zero-range sliders and zero-speed drag values](https://github.com/emilk/egui/pull/216).
-* Fixed false id clash error for wrapping text.
+* Fix false id clash error for wrapping text.
-* Fixed bug that would close a popup (e.g. the color picker) when clicking inside of it.
+* Fix bug that would close a popup (e.g. the color picker) when clicking inside of it.
 
 ### Deprecated ☢️
 * Deprectated `combo_box_with_label` in favor of new `ComboBox`.
@@ -606,12 +481,12 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 <img src="media/egui-0.10-plot.gif" width="50%">
 
 ### Added ⭐
-* Added `egui::plot::Plot` to plot some 2D data.
+* Add `egui::plot::Plot` to plot some 2D data.
-* Added `Ui::hyperlink_to(label, url)`.
+* Add `Ui::hyperlink_to(label, url)`.
 * Sliders can now have a value prefix and suffix (e.g. the suffix `"°"` works like a unit).
 * `Context::set_pixels_per_point` to control the scale of the UI.
-* Added `Response::changed()` to query if e.g. a slider was dragged, text was entered or a checkbox was clicked.
+* Add `Response::changed()` to query if e.g. a slider was dragged, text was entered or a checkbox was clicked.
-* Added support for all integers in `DragValue` and `Slider` (except 128-bit).
+* Add support for all integers in `DragValue` and `Slider` (except 128-bit).
 
 ### Changed 🔧
 * Improve the positioning of tooltips.
@@ -625,18 +500,18 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 <img src="media/0.9.0-disabled.gif" width="50%">
 
 ### Added ⭐
-* Added support for secondary and middle mouse buttons.
+* Add support for secondary and middle mouse buttons.
-* Added `Label` methods for code, strong, strikethrough, underline and italics.
+* Add `Label` methods for code, strong, strikethrough, underline and italics.
-* Added `ui.group(|ui| { … })` to visually group some widgets within a frame.
+* Add `ui.group(|ui| { … })` to visually group some widgets within a frame.
-* Added `Ui` helpers for doing manual layout (`ui.put`, `ui.allocate_ui_at_rect` and more).
+* Add `Ui` helpers for doing manual layout (`ui.put`, `ui.allocate_ui_at_rect` and more).
-* Added `ui.set_enabled(false)` to disable all widgets in a `Ui` (grayed out and non-interactive).
+* Add `ui.set_enabled(false)` to disable all widgets in a `Ui` (grayed out and non-interactive).
-* Added `TextEdit::hint_text` for showing a weak hint text when empty.
+* Add `TextEdit::hint_text` for showing a weak hint text when empty.
 * `egui::popup::popup_below_widget`: show a popup area below another widget.
-* Added `Slider::clamp_to_range(bool)`: if set, clamp the incoming and outgoing values to the slider range.
+* Add `Slider::clamp_to_range(bool)`: if set, clamp the incoming and outgoing values to the slider range.
 * Add: `ui.spacing()`, `ui.spacing_mut()`, `ui.visuals()`, `ui.visuals_mut()`.
 * Add: `ctx.set_visuals()`.
 * You can now control text wrapping with `Style::wrap`.
-* Added `Grid::max_col_width`.
+* Add `Grid::max_col_width`.
 
 ### Changed 🔧
 * Text will now wrap at newlines, spaces, dashes, punctuation or in the middle of a words if necessary, in that order of priority.
@@ -668,9 +543,9 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 
 ### Changed 🔧
 * New simpler and sleeker look!
-* Renamed `PaintCmd` to `Shape`.
+* Rename `PaintCmd` to `Shape`.
 * Replace tuple `(Rect, Shape)` with tuple-struct `ClippedShape`.
-* Renamed feature `"serde"` to `"persistence"`.
+* Rename feature `"serde"` to `"persistence"`.
 * Break out the modules `math` and `paint` into separate crates `emath` and `epaint`.
 
 ### Fixed 🐛
@@ -681,8 +556,8 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 ## 0.7.0 - 2021-01-04
 
 ### Added ⭐
-* Added `ui.scroll_to_cursor` and `response.scroll_to_me` ([#81](https://github.com/emilk/egui/pull/81) by [lucaspoffo](https://github.com/lucaspoffo)).
+* Add `ui.scroll_to_cursor` and `response.scroll_to_me` ([#81](https://github.com/emilk/egui/pull/81) by [lucaspoffo](https://github.com/lucaspoffo)).
-* Added `window.id(…)` and `area.id(…)` for overriding the default `Id`.
+* Add `window.id(…)` and `area.id(…)` for overriding the default `Id`.
 
 ### Changed 🔧
 * Renamed `Srgba` to `Color32`.
@@ -708,10 +583,10 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Mouse-over explanation to duplicate ID warning.
 * You can now easily constrain egui to a portion of the screen using `RawInput::screen_rect`.
 * You can now control the minimum and maixumum number of decimals to show in a `Slider` or `DragValue`.
-* Added `egui::math::Rot2`: rotation helper.
+* Add `egui::math::Rot2`: rotation helper.
 * `Response` now contains the `Id` of the widget it pertains to.
 * `ui.allocate_response` that allocates space and checks for interactions.
-* Added `response.interact(sense)`, e.g. to check for clicks on labels.
+* Add `response.interact(sense)`, e.g. to check for clicks on labels.
 
 ### Changed 🔧
 * `ui.allocate_space` now returns an `(Id, Rect)` tuple.
@@ -726,7 +601,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * Combo boxes has scroll bars when needed.
 * Expand `Window` + `Resize` containers to be large enough for last frames content
 * `ui.columns`: Columns now defaults to justified top-to-down layouts.
-* Renamed `Sense::nothing()` to  `Sense::hover()`.
+* Rename `Sense::nothing()` to  `Sense::hover()`.
 * Replaced `parking_lot` dependency with `atomic_refcell` by default.
 
 ### Fixed 🐛
@@ -752,7 +627,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * `SelectableLabel` (`ui.selectable_label` and `ui.selectable_value`): A text-button that can be selected.
 * `ui.small_button`: A smaller button that looks good embedded in text.
 * `ui.drag_angle_tau`: For those who want to specify angles as fractions of τ (a full turn).
-* Added `Resize::id_source` and `ScrollArea::id_source` to let the user avoid Id clashes.
+* Add `Resize::id_source` and `ScrollArea::id_source` to let the user avoid Id clashes.
 
 ### Changed 🔧
 * New default font: [Ubuntu-Light](https://fonts.google.com/specimen/Ubuntu).
@@ -795,7 +670,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 ### Added ⭐
 * Panels: you can now create panels using `SidePanel`, `TopPanel` and `CentralPanel`.
 * You can now override the default egui fonts.
-* Added ability to override text color with `visuals.override_text_color`.
+* Add ability to override text color with `visuals.override_text_color`.
 * The demo now includes a simple drag-and-drop example.
 * The demo app now has a slider to scale all of egui.
 
@@ -812,7 +687,7 @@ NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG
 * You can no longer throw windows.
 
 ### Fixed 🐛
-* Fixed a bug where some regions would slowly grow for non-integral scales (`pixels_per_point`).
+* Fix a bug where some regions would slowly grow for non-integral scales (`pixels_per_point`).
 
 
 ## 0.2.0 - 2020-10-10

Cargo.toml

@@ -1,20 +1,35 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/ecolor",
+    "egui_demo_app",
-    "crates/egui_demo_app",
+    "egui_demo_lib",
-    "crates/egui_demo_lib",
+    "egui_extras",
-    "crates/egui_extras",
+    "egui_glium",
-    "crates/egui_glow",
+    "egui_glow",
-    "crates/egui-wgpu",
+    "egui-wgpu",
-    "crates/egui-winit",
+    "egui-winit",
-    "crates/egui",
+    "egui",
-    "crates/emath",
+    "emath",
-    "crates/epaint",
+    "epaint",
 
-    "examples/*",
+    "examples/confirm_exit",
+    "examples/custom_3d_glow",
+    "examples/custom_3d_three-d",
+    "examples/custom_font",
+    "examples/custom_font_style",
+    "examples/custom_window_frame",
+    "examples/download_image",
+    "examples/file_dialog",
+    "examples/hello_world",
+    "examples/puffin_profiler",
+    "examples/retained_image",
+    "examples/screenshot",
+    "examples/svg",
 ]
 
+[profile.dev]
+split-debuginfo = "unpacked" # faster debug builds on mac
+
 [profile.release]
 # lto = true # VERY slightly smaller wasm
 # opt-level = 's' # 10-20% smaller wasm compared to `opt-level = 3`
@@ -23,13 +38,3 @@ opt-level = 2 # fast and small wasm, basically same as `opt-level = 's'`
 # opt-level = 3 # unecessarily large wasm for no performance gain
 
 # debug = true # include debug symbols, useful when profiling wasm
-
-
-[profile.dev]
-# Can't leave this on by default, because it breaks the Windows build. Related: https://github.com/rust-lang/cargo/issues/4897
-# split-debuginfo = "unpacked" # faster debug builds on mac
-# opt-level = 1                # Make debug builds run faster
-
-# Optimize all dependencies even in debug builds (does not affect workspace packages):
-[profile.dev.package."*"]
-opt-level = 2

Cranky.toml

@@ -1,124 +0,0 @@
-# https://github.com/ericseppanen/cargo-cranky
-# cargo install cargo-cranky && cargo cranky
-
-deny = ["unsafe_code"]
-
-warn = [
-  "clippy::all",
-  "clippy::await_holding_lock",
-  "clippy::bool_to_int_with_if",
-  "clippy::char_lit_as_u8",
-  "clippy::checked_conversions",
-  "clippy::cloned_instead_of_copied",
-  "clippy::dbg_macro",
-  "clippy::debug_assert_with_mut_call",
-  "clippy::derive_partial_eq_without_eq",
-  "clippy::disallowed_methods",
-  "clippy::disallowed_script_idents",
-  "clippy::doc_link_with_quotes",
-  "clippy::doc_markdown",
-  "clippy::empty_enum",
-  "clippy::enum_glob_use",
-  "clippy::equatable_if_let",
-  "clippy::exit",
-  "clippy::expl_impl_clone_on_copy",
-  "clippy::explicit_deref_methods",
-  "clippy::explicit_into_iter_loop",
-  "clippy::explicit_iter_loop",
-  "clippy::fallible_impl_from",
-  "clippy::filter_map_next",
-  "clippy::flat_map_option",
-  "clippy::float_cmp_const",
-  "clippy::fn_params_excessive_bools",
-  "clippy::fn_to_numeric_cast_any",
-  "clippy::from_iter_instead_of_collect",
-  "clippy::if_let_mutex",
-  "clippy::implicit_clone",
-  "clippy::imprecise_flops",
-  "clippy::index_refutable_slice",
-  "clippy::inefficient_to_string",
-  "clippy::invalid_upcast_comparisons",
-  "clippy::iter_not_returning_iterator",
-  "clippy::iter_on_empty_collections",
-  "clippy::iter_on_single_items",
-  "clippy::large_digit_groups",
-  "clippy::large_stack_arrays",
-  "clippy::large_types_passed_by_value",
-  "clippy::let_unit_value",
-  "clippy::linkedlist",
-  "clippy::lossy_float_literal",
-  "clippy::macro_use_imports",
-  "clippy::manual_assert",
-  "clippy::manual_instant_elapsed",
-  "clippy::manual_ok_or",
-  "clippy::manual_string_new",
-  "clippy::map_err_ignore",
-  "clippy::map_flatten",
-  "clippy::map_unwrap_or",
-  "clippy::match_on_vec_items",
-  "clippy::match_same_arms",
-  "clippy::match_wild_err_arm",
-  "clippy::match_wildcard_for_single_variants",
-  "clippy::mem_forget",
-  "clippy::mismatched_target_os",
-  "clippy::mismatching_type_param_order",
-  "clippy::missing_enforced_import_renames",
-  "clippy::missing_errors_doc",
-  "clippy::missing_safety_doc",
-  "clippy::mut_mut",
-  "clippy::mutex_integer",
-  "clippy::needless_borrow",
-  "clippy::needless_continue",
-  "clippy::needless_for_each",
-  "clippy::needless_pass_by_value",
-  "clippy::negative_feature_names",
-  "clippy::nonstandard_macro_braces",
-  "clippy::option_option",
-  "clippy::path_buf_push_overwrite",
-  "clippy::ptr_as_ptr",
-  "clippy::rc_mutex",
-  "clippy::ref_option_ref",
-  "clippy::rest_pat_in_fully_bound_structs",
-  "clippy::same_functions_in_if_condition",
-  "clippy::semicolon_if_nothing_returned",
-  "clippy::single_match_else",
-  "clippy::str_to_string",
-  "clippy::string_add_assign",
-  "clippy::string_add",
-  "clippy::string_lit_as_bytes",
-  "clippy::string_to_string",
-  "clippy::todo",
-  "clippy::trailing_empty_array",
-  "clippy::trait_duplication_in_bounds",
-  "clippy::unimplemented",
-  "clippy::unnecessary_wraps",
-  "clippy::unnested_or_patterns",
-  "clippy::unused_peekable",
-  "clippy::unused_rounding",
-  "clippy::unused_self",
-  "clippy::useless_transmute",
-  "clippy::verbose_file_reads",
-  "clippy::zero_sized_map_values",
-  "elided_lifetimes_in_paths",
-  "future_incompatible",
-  "nonstandard_style",
-  "rust_2018_idioms",
-  "rust_2021_prelude_collisions",
-  "rustdoc::missing_crate_level_docs",
-  "semicolon_in_expressions_from_macros",
-  "trivial_numeric_casts",
-  "unused_extern_crates",
-  "unused_import_braces",
-  "unused_lifetimes",
-]
-
-allow = [
-  "clippy::manual_range_contains", # This one is just annoying
-
-  # Some of these we should try to put in "warn":
-  "clippy::type_complexity",
-  "clippy::undocumented_unsafe_blocks",
-  "trivial_casts",
-  "unsafe_op_in_unsafe_fn",             # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
-  "unused_qualifications",
-]

README.md

@@ -11,7 +11,7 @@
 
 👉 [Click to run the web demo](https://www.egui.rs/#demo) 👈
 
-egui (pronounced "e-gooey") is a simple, fast, and highly portable immediate mode GUI library for Rust. egui runs on the web, natively, and [in your favorite game engine](#integrations) (or will soon).
+egui is a simple, fast, and highly portable immediate mode GUI library for Rust. egui runs on the web, natively, and [in your favorite game engine](#integrations) (or will soon).
 
 egui aims to be the easiest-to-use Rust GUI library, and the simplest way to make a web app in Rust.
 
@@ -60,17 +60,17 @@ If you have questions, use [GitHub Discussions](https://github.com/emilk/egui/di
 
 ## Demo
 
-[Click to run egui web demo](https://www.egui.rs/#demo) (works in any browser with WASM and WebGL support). Uses [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+[Click to run egui web demo](https://www.egui.rs/#demo) (works in any browser with WASM and WebGL support). Uses [`eframe`](https://github.com/emilk/egui/tree/master/eframe).
 
 To test the demo app locally, run `cargo run --release -p egui_demo_app`.
 
-The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) (using [`glow`](https://crates.io/crates/glow)) and should work out-of-the-box on Mac and Windows, but on Linux you need to first run:
+The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) (using [`glow`](https://crates.io/crates/glow)) and should work out-of-the-box on Mac and Windows, but on Linux you need to first run:
 
-`sudo apt-get install -y libclang-dev libgtk-3-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev`
+`sudo apt-get install -y libclang-dev libgtk-3-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libspeechd-dev libxkbcommon-dev libssl-dev`
 
 On Fedora Rawhide you need to run:
 
-`dnf install clang clang-devel clang-tools-extra libxkbcommon-devel pkg-config openssl-devel libxcb-devel`
+`dnf install clang clang-devel clang-tools-extra speech-dispatcher-devel libxkbcommon-devel pkg-config openssl-devel libxcb-devel`
 
 **NOTE**: This is just for the demo app - egui itself is completely platform agnostic!
 
@@ -84,7 +84,7 @@ On Fedora Rawhide you need to run:
 * A simple 2D graphics API for custom painting ([`epaint`](https://docs.rs/epaint)).
 * No callbacks
 * Pure immediate mode
-* Extensible: [easy to write your own widgets for egui](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/toggle_switch.rs)
+* Extensible: [easy to write your own widgets for egui](https://github.com/emilk/egui/blob/master/egui_demo_lib/src/demo/toggle_switch.rs)
 * Modular: You should be able to use small parts of egui and combine them in new ways
 * Safe: there is no `unsafe` code in egui
 * Minimal dependencies: [`ab_glyph`](https://crates.io/crates/ab_glyph) [`ahash`](https://crates.io/crates/ahash) [`nohash-hasher`](https://crates.io/crates/nohash-hasher) [`parking_lot`](https://crates.io/crates/parking_lot)
@@ -114,7 +114,7 @@ The obvious alternative to egui is [`imgui-rs`](https://github.com/Gekkio/imgui-
 * egui is pure Rust
 * egui is easily compiled to WASM
 * egui lets you use native Rust string types (`imgui-rs` forces you to use annoying macros and wrappers for zero-terminated strings)
-* [Writing your own widgets in egui is simple](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/toggle_switch.rs)
+* [Writing your own widgets in egui is simple](https://github.com/emilk/egui/blob/master/egui_demo_lib/src/demo/toggle_switch.rs)
 
 egui also tries to improve your experience in other small ways:
 
@@ -158,42 +158,37 @@ An integration needs to do the following each frame:
 * **Input**: Gather input (mouse, touches, keyboard, screen size, etc) and give it to egui
 * Run the application code
 * **Output**: Handle egui output (cursor changes, paste, texture allocations, …)
-* **Painting**: Render the triangle mesh egui produces (see [OpenGL example](https://github.com/emilk/egui/blob/master/crates/egui_glow/src/painter.rs))
+* **Painting**: Render the triangle mesh egui produces (see [OpenGL example](https://github.com/emilk/egui/blob/master/egui_glium/src/painter.rs))
 
 ### Official integrations
 
 These are the official egui integrations:
 
-* [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) for compiling the same app to web/wasm and desktop/native. Uses `egui-winit` and `egui_glow` or `egui-wgpu`.
+* [`eframe`](https://github.com/emilk/egui/tree/master/eframe) for compiling the same app to web/wasm and desktop/native. Uses `egui_glow` and `egui-winit`.
-* [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) for rendering egui with [glow](https://github.com/grovesNL/glow) on native and web, and for making native apps.
+* [`egui_glium`](https://github.com/emilk/egui/tree/master/egui_glium) for compiling native apps with [Glium](https://github.com/glium/glium).
-* [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu) for [wgpu](https://crates.io/crates/wgpu) (WebGPU API).
+* [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) for rendering egui with [glow](https://github.com/grovesNL/glow) on native and web, and for making native apps.
-* [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit) for integrating with [winit](https://github.com/rust-windowing/winit).
+* [`egui-wgpu`](https://github.com/emilk/egui/tree/master/egui-wgpu) for [wgpu](https://crates.io/crates/wgpu) (WebGPU API).
-* [`egui_glium`](https://github.com/emilk/egui/tree/master/crates/egui_glium) for compiling native apps with [Glium](https://github.com/glium/glium) (DEPRECATED - looking for new maintainer).
+* [`egui-winit`](https://github.com/emilk/egui/tree/master/egui-winit) for integrating with [winit](https://github.com/rust-windowing/winit).
 
 ### 3rd party integrations
 
 * [`amethyst_egui`](https://github.com/jgraef/amethyst_egui) for [the Amethyst game engine](https://amethyst.rs/).
 * [`bevy_egui`](https://github.com/mvlabat/bevy_egui) for [the Bevy game engine](https://bevyengine.org/).
 * [`egui_glfw_gl`](https://github.com/cohaereo/egui_glfw_gl) for [GLFW](https://crates.io/crates/glfw).
-* [`egui-glutin-gl`](https://github.com/h3r2tic/egui-glutin-gl/) for [glutin](https://crates.io/crates/glutin).
 * [`egui_sdl2_gl`](https://crates.io/crates/egui_sdl2_gl) for [SDL2](https://crates.io/crates/sdl2).
-* [`egui_sdl2_platform`](https://github.com/ComLarsic/egui_sdl2_platform) for [SDL2](https://crates.io/crates/sdl2).
 * [`egui_vulkano`](https://github.com/derivator/egui_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
 * [`egui_winit_vulkano`](https://github.com/hakolao/egui_winit_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
 * [`egui-macroquad`](https://github.com/optozorax/egui-macroquad) for [macroquad](https://github.com/not-fl3/macroquad).
 * [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad) for [Miniquad](https://github.com/not-fl3/miniquad).
-* [`egui_speedy2d`](https://github.com/heretik31/egui_speedy2d) for [Speedy2d](https://github.com/QuantumBadger/Speedy2D).
 * [`egui-tetra`](https://crates.io/crates/egui-tetra) for [Tetra](https://crates.io/crates/tetra), a 2D game framework.
 * [`egui-winit-ash-integration`](https://github.com/MatchaChoco010/egui-winit-ash-integration) for [winit](https://github.com/rust-windowing/winit) and [ash](https://github.com/MaikKlein/ash).
 * [`fltk-egui`](https://crates.io/crates/fltk-egui) for [fltk-rs](https://github.com/fltk-rs/fltk-rs).
-* [`ggegui`](https://github.com/NemuiSen/ggegui) for the [ggez](https://ggez.rs/) game framework.
+* [`ggez-egui`](https://github.com/NemuiSen/ggez-egui) for the [ggez](https://ggez.rs/) game framework.
 * [`godot-egui`](https://github.com/setzer22/godot-egui) for [godot-rust](https://github.com/godot-rust/godot-rust).
-* [`nannou_egui`](https://github.com/nannou-org/nannou/tree/master/nannou_egui) for [nannou](https://nannou.cc).
+* [`nannou_egui`](https://github.com/AlexEne/nannou_egui) for [nannou](https://nannou.cc).
 * [`notan_egui`](https://github.com/Nazariglez/notan/tree/main/crates/notan_egui) for [notan](https://github.com/Nazariglez/notan).
 * [`screen-13-egui`](https://github.com/attackgoat/screen-13/tree/master/contrib/screen-13-egui) for [Screen 13](https://github.com/attackgoat/screen-13).
-* [`egui_skia`](https://github.com/lucasmerlin/egui_skia) for [skia](https://github.com/rust-skia/rust-skia/tree/master/skia-safe).
 * [`smithay-egui`](https://github.com/Smithay/smithay-egui) for [smithay](https://github.com/Smithay/smithay/).
-* [`tauri-egui`](https://github.com/tauri-apps/tauri-egui) for [tauri](https://github.com/tauri-apps/tauri).
 
 Missing an integration for the thing you're working on? Create one, it's easy!
 
@@ -224,7 +219,7 @@ loop {
 }
 ```
 
-For a reference OpenGL backend, see [the `egui_glium` painter](https://github.com/emilk/egui/blob/master/crates/egui_glium/src/painter.rs) or [the `egui_glow` painter](https://github.com/emilk/egui/blob/master/crates/egui_glow/src/painter.rs).
+For a reference OpenGL backend, see [the `egui_glium` painter](https://github.com/emilk/egui/blob/master/egui_glium/src/painter.rs) or [the `egui_glow` painter](https://github.com/emilk/egui/blob/master/egui_glow/src/painter.rs).
 
 ### Debugging your integration
 
@@ -324,11 +319,11 @@ If you call `.await` in your GUI code, the UI will freeze, which is very bad UX.
 * [`tokio::sync::watch::channel`](https://docs.rs/tokio/latest/tokio/sync/watch/fn.channel.html)
 
 ### What about accessibility, such as screen readers?
-egui includes optional support for [AccessKit](https://accesskit.dev/), which currently implements the native accessibility APIs on Windows and macOS. This feature is enabled by default in eframe. For platforms that AccessKit doesn't yet support, including web, there is an experimental built-in screen reader; in [the web demo](https://www.egui.rs/#demo) you can enable it in the "Backend" tab.
+There is experimental support for a screen reader. In [the web demo](https://www.egui.rs/#demo) you can enable it in the "Backend" tab.
 
-The original discussion of accessibility in egui is at <https://github.com/emilk/egui/issues/167>. Now that AccessKit support is merged, providing a strong foundation for future accessibility work, please open new issues on specific accessibility problems.
+Read more at <https://github.com/emilk/egui/issues/167>.
 
-### What is the difference between [egui](https://docs.rs/egui) and [eframe](https://github.com/emilk/egui/tree/master/crates/eframe)?
+### What is the difference between [egui](https://docs.rs/egui) and [eframe](https://github.com/emilk/egui/tree/master/eframe)?
 
 `egui` is a 2D user interface library for laying out and interacting with buttons, sliders, etc.
 `egui` has no idea if it is running on the web or natively, and does not know how to collect input or show things on screen.
@@ -348,14 +343,14 @@ Examples:
 * <https://github.com/emilk/egui/blob/master/examples/custom_3d_three-d.rs>
 * <https://github.com/emilk/egui/blob/master/examples/custom_3d_glow.rs>
 
-`Shape::Callback` will call your code when egui gets painted, to show anything using whatever the background rendering context is. When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) this will be [`glow`](https://github.com/grovesNL/glow). Other integrations will give you other rendering contexts, if they support `Shape::Callback` at all.
+`Shape::Callback` will call your code when egui gets painted, to show anything using whatever the background rendering context is. When using [`eframe`](https://github.com/emilk/egui/tree/master/eframe) this will be [`glow`](https://github.com/grovesNL/glow). Other integrations will give you other rendering contexts, if they support `Shape::Callback` at all.
 
 #### Render-to-texture
 You can also render your 3D scene to a texture and display it using [`ui.image(…)`](https://docs.rs/egui/latest/egui/struct.Ui.html#method.image). You first need to convert the native texture to an [`egui::TextureId`](https://docs.rs/egui/latest/egui/enum.TextureId.html), and how to do this depends on the integration you use.
 
 Examples:
 * Using [`egui-miniquad`]( https://github.com/not-fl3/egui-miniquad): https://github.com/not-fl3/egui-miniquad/blob/master/examples/render_to_egui_image.rs
-* Using [`egui_glium`](https://github.com/emilk/egui/tree/master/crates/egui_glium): <https://github.com/emilk/egui/blob/master/crates/egui_glium/examples/native_texture.rs>.
+* Using [`egui_glium`](https://github.com/emilk/egui/tree/master/egui_glium): <https://github.com/emilk/egui/blob/master/egui_glium/examples/native_texture.rs>.
 
 
 ## Other
@@ -372,8 +367,6 @@ egui uses the builder pattern for construction widgets. For instance: `ui.add(La
 
 Instead of using matching `begin/end` style function calls (which can be error prone) egui prefers to use `FnOnce` closures passed to a wrapping function. Lambdas are a bit ugly though, so I'd like to find a nicer solution to this. More discussion of this at <https://github.com/emilk/egui/issues/1004#issuecomment-1001650754>.
 
-egui uses a single `RwLock` for short-time locks on each access of `Context` data. This is to leave implementation simple and transactional and allow users to run their UI logic in parallel. Instead of creating mutex guards, egui uses closures passed to a wrapping function, e.g. `ctx.input(|i| i.key_down(Key::A))`. This is to make it less likely that a user would accidentally double-lock the `Context`, which would lead to a deadlock.
-
 ### Inspiration
 
 The one and only [Dear ImGui](https://github.com/ocornut/imgui) is a great Immediate Mode GUI for C++ which works with many backends. That library revolutionized how I think about GUI code and turned GUI programming from something I hated to do to something I now enjoy.
@@ -399,7 +392,6 @@ Notable contributions by:
 * [@mankinskin](https://github.com/mankinskin): [Context menus](https://github.com/emilk/egui/pull/543).
 * [@t18b219k](https://github.com/t18b219k): [Port glow painter to web](https://github.com/emilk/egui/pull/868).
 * [@danielkeller](https://github.com/danielkeller): [`Context` refactor](https://github.com/emilk/egui/pull/1050).
-* [@MaximOsipenko](https://github.com/MaximOsipenko): [`Context` lock refactor](https://github.com/emilk/egui/pull/2625).
 * And [many more](https://github.com/emilk/egui/graphs/contributors?type=a).
 
 egui is licensed under [MIT](LICENSE-MIT) OR [Apache-2.0](LICENSE-APACHE).
@@ -412,12 +404,3 @@ Default fonts:
 * `Hack-Regular.ttf`: <https://github.com/source-foundry/Hack>, [MIT Licence](https://github.com/source-foundry/Hack/blob/master/LICENSE.md)
 * `NotoEmoji-Regular.ttf`: [google.com/get/noto](https://google.com/get/noto), [SIL Open Font License](https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL)
 * `Ubuntu-Light.ttf` by [Dalton Maag](http://www.daltonmaag.com/): [Ubuntu font licence](https://ubuntu.com/legal/font-licence)
-
----
-
-<div align="center">
-<img src="media/rerun_io_logo.png" width="50%">
-
-egui development is sponsored by [Rerun](https://www.rerun.io/), a startup doing<br>
-visualizations for computer vision and robotics.
-</div>

bacon.toml

@@ -1,46 +0,0 @@
-# This is a configuration file for the bacon tool
-# More info at https://github.com/Canop/bacon
-
-default_job = "cranky"
-
-[jobs]
-
-[jobs.cranky]
-command = ["cargo", "cranky", "--all-targets", "--all-features", "--color", "always"]
-need_stdout = false
-watch = ["tests", "benches", "examples"]
-
-[jobs.test]
-command = ["cargo", "test", "--color", "always"]
-need_stdout = true
-watch = ["tests"]
-
-[jobs.doc]
-command = ["cargo", "doc", "--color", "always", "--all-features", "--no-deps"]
-need_stdout = false
-
-# if the doc compiles, then it opens in your browser and bacon switches
-# to the previous job
-[jobs.doc-open]
-command = ["cargo", "doc", "--color", "always", "--all-features", "--no-deps", "--open"]
-need_stdout = false
-on_success = "back" # so that we don't open the browser at each change
-
-# You can run your application and have the result displayed in bacon,
-# *if* it makes sense for this crate. You can run an example the same
-# way. Don't forget the `--color always` part or the errors won't be
-# properly parsed.
-[jobs.run]
-command = ["cargo", "run", "--color", "always"]
-need_stdout = true
-
-# You may define here keybindings that would be specific to
-# a project, for example a shortcut to launch a specific job.
-# Shortcuts to internal functions (scrolling, toggling, etc.)
-# should go in your personal prefs.toml file instead.
-[keybindings]
-i = "job:initial"
-c = "job:cranky"
-d = "job:doc-open"
-t = "job:test"
-r = "job:run"

clippy.toml

@@ -1 +0,0 @@
-doc-valid-idents = ["AccessKit", ".."]

crates/ecolor/CHANGELOG.md

@@ -1,13 +0,0 @@
-# Changelog for ecolor
-All notable changes to the `ecolor` crate will be noted in this file.
-
-
-## Unreleased
-
-
-## 0.21.0 - 2023-02-08
-* Add `Color32::gamma_multiply` ([#2437](https://github.com/emilk/egui/pull/2437)).
-
-
-## 0.20.0 - 2022-12-08
-* Split out `ecolor` crate from `epaint`

crates/ecolor/Cargo.toml

@@ -1,50 +0,0 @@
-[package]
-name = "ecolor"
-version = "0.21.0"
-authors = [
-  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
-  "Andreas Reich <reichandreas@gmx.de>",
-]
-description = "Color structs and color conversion utilities"
-edition = "2021"
-rust-version = "1.65"
-homepage = "https://github.com/emilk/egui"
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/emilk/egui"
-categories = ["mathematics", "encoding"]
-keywords = ["gui", "color", "conversion", "gamedev", "images"]
-include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
-
-[package.metadata.docs.rs]
-all-features = true
-
-[lib]
-
-
-[features]
-default = []
-
-## Enable additional checks if debug assertions are enabled (debug builds).
-extra_debug_asserts = []
-## Always enable additional checks.
-extra_asserts = []
-
-
-[dependencies]
-#! ### Optional dependencies
-
-## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast `ecolor` types to `&[u8]`.
-bytemuck = { version = "1.7.2", optional = true, features = ["derive"] }
-
-## [`cint`](https://docs.rs/cint) enables interopability with other color libraries.
-cint = { version = "0.3.1", optional = true }
-
-## Enable the [`hex_color`] macro.
-color-hex = { version = "0.2.0", optional = true }
-
-## Enable this when generating docs.
-document-features = { version = "0.2", optional = true }
-
-## Allow serialization using [`serde`](https://docs.rs/serde).
-serde = { version = "1", optional = true, features = ["derive"] }

crates/ecolor/README.md

@@ -1,11 +0,0 @@
-# ecolor - egui color library
-
-[![Latest version](https://img.shields.io/crates/v/ecolor.svg)](https://crates.io/crates/ecolor)
-[![Documentation](https://docs.rs/ecolor/badge.svg)](https://docs.rs/ecolor)
-[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
-![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
-
-A simple color storage and conversion library.
-
-Made for [`egui`](https://github.com/emilk/egui/).

crates/ecolor/src/cint_impl.rs

@@ -1,161 +0,0 @@
-use super::*;
-use cint::{Alpha, ColorInterop, EncodedSrgb, Hsv, LinearSrgb, PremultipliedAlpha};
-
-// ---- Color32 ----
-
-impl From<Alpha<EncodedSrgb<u8>>> for Color32 {
-    fn from(srgba: Alpha<EncodedSrgb<u8>>) -> Self {
-        let Alpha {
-            color: EncodedSrgb { r, g, b },
-            alpha: a,
-        } = srgba;
-
-        Color32::from_rgba_unmultiplied(r, g, b, a)
-    }
-}
-
-// No From<Color32> for Alpha<_> because Color32 is premultiplied
-
-impl From<PremultipliedAlpha<EncodedSrgb<u8>>> for Color32 {
-    fn from(srgba: PremultipliedAlpha<EncodedSrgb<u8>>) -> Self {
-        let PremultipliedAlpha {
-            color: EncodedSrgb { r, g, b },
-            alpha: a,
-        } = srgba;
-
-        Color32::from_rgba_premultiplied(r, g, b, a)
-    }
-}
-
-impl From<Color32> for PremultipliedAlpha<EncodedSrgb<u8>> {
-    fn from(col: Color32) -> Self {
-        let (r, g, b, a) = col.to_tuple();
-
-        PremultipliedAlpha {
-            color: EncodedSrgb { r, g, b },
-            alpha: a,
-        }
-    }
-}
-
-impl From<PremultipliedAlpha<EncodedSrgb<f32>>> for Color32 {
-    fn from(srgba: PremultipliedAlpha<EncodedSrgb<f32>>) -> Self {
-        let PremultipliedAlpha {
-            color: EncodedSrgb { r, g, b },
-            alpha: a,
-        } = srgba;
-
-        // This is a bit of an abuse of the function name but it does what we want.
-        let r = linear_u8_from_linear_f32(r);
-        let g = linear_u8_from_linear_f32(g);
-        let b = linear_u8_from_linear_f32(b);
-        let a = linear_u8_from_linear_f32(a);
-
-        Color32::from_rgba_premultiplied(r, g, b, a)
-    }
-}
-
-impl From<Color32> for PremultipliedAlpha<EncodedSrgb<f32>> {
-    fn from(col: Color32) -> Self {
-        let (r, g, b, a) = col.to_tuple();
-
-        // This is a bit of an abuse of the function name but it does what we want.
-        let r = linear_f32_from_linear_u8(r);
-        let g = linear_f32_from_linear_u8(g);
-        let b = linear_f32_from_linear_u8(b);
-        let a = linear_f32_from_linear_u8(a);
-
-        PremultipliedAlpha {
-            color: EncodedSrgb { r, g, b },
-            alpha: a,
-        }
-    }
-}
-
-impl ColorInterop for Color32 {
-    type CintTy = PremultipliedAlpha<EncodedSrgb<u8>>;
-}
-
-// ---- Rgba ----
-
-impl From<PremultipliedAlpha<LinearSrgb<f32>>> for Rgba {
-    fn from(srgba: PremultipliedAlpha<LinearSrgb<f32>>) -> Self {
-        let PremultipliedAlpha {
-            color: LinearSrgb { r, g, b },
-            alpha: a,
-        } = srgba;
-
-        Rgba([r, g, b, a])
-    }
-}
-
-impl From<Rgba> for PremultipliedAlpha<LinearSrgb<f32>> {
-    fn from(col: Rgba) -> Self {
-        let (r, g, b, a) = col.to_tuple();
-
-        PremultipliedAlpha {
-            color: LinearSrgb { r, g, b },
-            alpha: a,
-        }
-    }
-}
-
-impl ColorInterop for Rgba {
-    type CintTy = PremultipliedAlpha<LinearSrgb<f32>>;
-}
-
-// ---- Hsva ----
-
-impl From<Alpha<Hsv<f32>>> for Hsva {
-    fn from(srgba: Alpha<Hsv<f32>>) -> Self {
-        let Alpha {
-            color: Hsv { h, s, v },
-            alpha: a,
-        } = srgba;
-
-        Hsva::new(h, s, v, a)
-    }
-}
-
-impl From<Hsva> for Alpha<Hsv<f32>> {
-    fn from(col: Hsva) -> Self {
-        let Hsva { h, s, v, a } = col;
-
-        Alpha {
-            color: Hsv { h, s, v },
-            alpha: a,
-        }
-    }
-}
-
-impl ColorInterop for Hsva {
-    type CintTy = Alpha<Hsv<f32>>;
-}
-
-// ---- HsvaGamma ----
-
-impl ColorInterop for HsvaGamma {
-    type CintTy = Alpha<Hsv<f32>>;
-}
-
-impl From<Alpha<Hsv<f32>>> for HsvaGamma {
-    fn from(srgba: Alpha<Hsv<f32>>) -> Self {
-        let Alpha {
-            color: Hsv { h, s, v },
-            alpha: a,
-        } = srgba;
-
-        Hsva::new(h, s, v, a).into()
-    }
-}
-
-impl From<HsvaGamma> for Alpha<Hsv<f32>> {
-    fn from(col: HsvaGamma) -> Self {
-        let Hsva { h, s, v, a } = col.into();
-
-        Alpha {
-            color: Hsv { h, s, v },
-            alpha: a,
-        }
-    }
-}

crates/ecolor/src/color32.rs

@@ -1,216 +0,0 @@
-use crate::{gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8, Rgba};
-
-/// This format is used for space-efficient color representation (32 bits).
-///
-/// Instead of manipulating this directly it is often better
-/// to first convert it to either [`Rgba`] or [`crate::Hsva`].
-///
-/// Internally this uses 0-255 gamma space `sRGBA` color with premultiplied alpha.
-/// Alpha channel is in linear space.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
-pub struct Color32(pub(crate) [u8; 4]);
-
-impl std::ops::Index<usize> for Color32 {
-    type Output = u8;
-
-    #[inline(always)]
-    fn index(&self, index: usize) -> &u8 {
-        &self.0[index]
-    }
-}
-
-impl std::ops::IndexMut<usize> for Color32 {
-    #[inline(always)]
-    fn index_mut(&mut self, index: usize) -> &mut u8 {
-        &mut self.0[index]
-    }
-}
-
-impl Color32 {
-    // Mostly follows CSS names:
-
-    pub const TRANSPARENT: Color32 = Color32::from_rgba_premultiplied(0, 0, 0, 0);
-    pub const BLACK: Color32 = Color32::from_rgb(0, 0, 0);
-    pub const DARK_GRAY: Color32 = Color32::from_rgb(96, 96, 96);
-    pub const GRAY: Color32 = Color32::from_rgb(160, 160, 160);
-    pub const LIGHT_GRAY: Color32 = Color32::from_rgb(220, 220, 220);
-    pub const WHITE: Color32 = Color32::from_rgb(255, 255, 255);
-
-    pub const BROWN: Color32 = Color32::from_rgb(165, 42, 42);
-    pub const DARK_RED: Color32 = Color32::from_rgb(0x8B, 0, 0);
-    pub const RED: Color32 = Color32::from_rgb(255, 0, 0);
-    pub const LIGHT_RED: Color32 = Color32::from_rgb(255, 128, 128);
-
-    pub const YELLOW: Color32 = Color32::from_rgb(255, 255, 0);
-    pub const LIGHT_YELLOW: Color32 = Color32::from_rgb(255, 255, 0xE0);
-    pub const KHAKI: Color32 = Color32::from_rgb(240, 230, 140);
-
-    pub const DARK_GREEN: Color32 = Color32::from_rgb(0, 0x64, 0);
-    pub const GREEN: Color32 = Color32::from_rgb(0, 255, 0);
-    pub const LIGHT_GREEN: Color32 = Color32::from_rgb(0x90, 0xEE, 0x90);
-
-    pub const DARK_BLUE: Color32 = Color32::from_rgb(0, 0, 0x8B);
-    pub const BLUE: Color32 = Color32::from_rgb(0, 0, 255);
-    pub const LIGHT_BLUE: Color32 = Color32::from_rgb(0xAD, 0xD8, 0xE6);
-
-    pub const GOLD: Color32 = Color32::from_rgb(255, 215, 0);
-
-    pub const DEBUG_COLOR: Color32 = Color32::from_rgba_premultiplied(0, 200, 0, 128);
-
-    /// An ugly color that is planned to be replaced before making it to the screen.
-    pub const TEMPORARY_COLOR: Color32 = Color32::from_rgb(64, 254, 0);
-
-    #[inline(always)]
-    pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
-        Self([r, g, b, 255])
-    }
-
-    #[inline(always)]
-    pub const fn from_rgb_additive(r: u8, g: u8, b: u8) -> Self {
-        Self([r, g, b, 0])
-    }
-
-    /// From `sRGBA` with premultiplied alpha.
-    #[inline(always)]
-    pub const fn from_rgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
-        Self([r, g, b, a])
-    }
-
-    /// From `sRGBA` WITHOUT premultiplied alpha.
-    pub fn from_rgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
-        if a == 255 {
-            Self::from_rgb(r, g, b) // common-case optimization
-        } else if a == 0 {
-            Self::TRANSPARENT // common-case optimization
-        } else {
-            let r_lin = linear_f32_from_gamma_u8(r);
-            let g_lin = linear_f32_from_gamma_u8(g);
-            let b_lin = linear_f32_from_gamma_u8(b);
-            let a_lin = linear_f32_from_linear_u8(a);
-
-            let r = gamma_u8_from_linear_f32(r_lin * a_lin);
-            let g = gamma_u8_from_linear_f32(g_lin * a_lin);
-            let b = gamma_u8_from_linear_f32(b_lin * a_lin);
-
-            Self::from_rgba_premultiplied(r, g, b, a)
-        }
-    }
-
-    #[inline(always)]
-    pub const fn from_gray(l: u8) -> Self {
-        Self([l, l, l, 255])
-    }
-
-    #[inline(always)]
-    pub const fn from_black_alpha(a: u8) -> Self {
-        Self([0, 0, 0, a])
-    }
-
-    pub fn from_white_alpha(a: u8) -> Self {
-        Rgba::from_white_alpha(linear_f32_from_linear_u8(a)).into()
-    }
-
-    #[inline(always)]
-    pub const fn from_additive_luminance(l: u8) -> Self {
-        Self([l, l, l, 0])
-    }
-
-    #[inline(always)]
-    pub const fn is_opaque(&self) -> bool {
-        self.a() == 255
-    }
-
-    #[inline(always)]
-    pub const fn r(&self) -> u8 {
-        self.0[0]
-    }
-
-    #[inline(always)]
-    pub const fn g(&self) -> u8 {
-        self.0[1]
-    }
-
-    #[inline(always)]
-    pub const fn b(&self) -> u8 {
-        self.0[2]
-    }
-
-    #[inline(always)]
-    pub const fn a(&self) -> u8 {
-        self.0[3]
-    }
-
-    /// Returns an opaque version of self
-    pub fn to_opaque(self) -> Self {
-        Rgba::from(self).to_opaque().into()
-    }
-
-    /// Returns an additive version of self
-    #[inline(always)]
-    pub const fn additive(self) -> Self {
-        let [r, g, b, _] = self.to_array();
-        Self([r, g, b, 0])
-    }
-
-    /// Premultiplied RGBA
-    #[inline(always)]
-    pub const fn to_array(&self) -> [u8; 4] {
-        [self.r(), self.g(), self.b(), self.a()]
-    }
-
-    /// Premultiplied RGBA
-    #[inline(always)]
-    pub const fn to_tuple(&self) -> (u8, u8, u8, u8) {
-        (self.r(), self.g(), self.b(), self.a())
-    }
-
-    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
-        Rgba::from(*self).to_srgba_unmultiplied()
-    }
-
-    /// Multiply with 0.5 to make color half as opaque, perceptually.
-    ///
-    /// Fast multiplication in gamma-space.
-    ///
-    /// This is perceptually even, and faster that [`Self::linear_multiply`].
-    #[inline]
-    pub fn gamma_multiply(self, factor: f32) -> Color32 {
-        crate::ecolor_assert!(0.0 <= factor && factor <= 1.0);
-        let Self([r, g, b, a]) = self;
-        Self([
-            (r as f32 * factor + 0.5) as u8,
-            (g as f32 * factor + 0.5) as u8,
-            (b as f32 * factor + 0.5) as u8,
-            (a as f32 * factor + 0.5) as u8,
-        ])
-    }
-
-    /// Multiply with 0.5 to make color half as opaque in linear space.
-    ///
-    /// This is using linear space, which is not perceptually even.
-    /// You may want to use [`Self::gamma_multiply`] instead.
-    pub fn linear_multiply(self, factor: f32) -> Color32 {
-        crate::ecolor_assert!(0.0 <= factor && factor <= 1.0);
-        // As an unfortunate side-effect of using premultiplied alpha
-        // we need a somewhat expensive conversion to linear space and back.
-        Rgba::from(self).multiply(factor).into()
-    }
-
-    /// Converts to floating point values in the range 0-1 without any gamma space conversion.
-    ///
-    /// Use this with great care! In almost all cases, you want to convert to [`crate::Rgba`] instead
-    /// in order to obtain linear space color values.
-    #[inline]
-    pub fn to_normalized_gamma_f32(self) -> [f32; 4] {
-        let Self([r, g, b, a]) = self;
-        [
-            r as f32 / 255.0,
-            g as f32 / 255.0,
-            b as f32 / 255.0,
-            a as f32 / 255.0,
-        ]
-    }
-}

crates/ecolor/src/hex_color_macro.rs

@@ -1,39 +0,0 @@
-/// Construct a [`crate::Color32`] from a hex RGB or RGBA string.
-///
-/// ```
-/// # use ecolor::{hex_color, Color32};
-/// assert_eq!(hex_color!("#202122"), Color32::from_rgb(0x20, 0x21, 0x22));
-/// assert_eq!(hex_color!("#abcdef12"), Color32::from_rgba_unmultiplied(0xab, 0xcd, 0xef, 0x12));
-/// ```
-#[macro_export]
-macro_rules! hex_color {
-    ($s:literal) => {{
-        let array = color_hex::color_from_hex!($s);
-        if array.len() == 3 {
-            $crate::Color32::from_rgb(array[0], array[1], array[2])
-        } else {
-            #[allow(unconditional_panic)]
-            $crate::Color32::from_rgba_unmultiplied(array[0], array[1], array[2], array[3])
-        }
-    }};
-}
-
-#[test]
-fn test_from_rgb_hex() {
-    assert_eq!(
-        crate::Color32::from_rgb(0x20, 0x21, 0x22),
-        hex_color!("#202122")
-    );
-    assert_eq!(
-        crate::Color32::from_rgb_additive(0x20, 0x21, 0x22),
-        hex_color!("#202122").additive()
-    );
-}
-
-#[test]
-fn test_from_rgba_hex() {
-    assert_eq!(
-        crate::Color32::from_rgba_unmultiplied(0x20, 0x21, 0x22, 0x50),
-        hex_color!("20212250")
-    );
-}

crates/ecolor/src/hsva.rs

@@ -1,231 +0,0 @@
-use crate::{
-    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
-    linear_u8_from_linear_f32, Color32, Rgba,
-};
-
-/// Hue, saturation, value, alpha. All in the range [0, 1].
-/// No premultiplied alpha.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Hsva {
-    /// hue 0-1
-    pub h: f32,
-
-    /// saturation 0-1
-    pub s: f32,
-
-    /// value 0-1
-    pub v: f32,
-
-    /// alpha 0-1. A negative value signifies an additive color (and alpha is ignored).
-    pub a: f32,
-}
-
-impl Hsva {
-    pub fn new(h: f32, s: f32, v: f32, a: f32) -> Self {
-        Self { h, s, v, a }
-    }
-
-    /// From `sRGBA` with premultiplied alpha
-    pub fn from_srgba_premultiplied(srgba: [u8; 4]) -> Self {
-        Self::from_rgba_premultiplied(
-            linear_f32_from_gamma_u8(srgba[0]),
-            linear_f32_from_gamma_u8(srgba[1]),
-            linear_f32_from_gamma_u8(srgba[2]),
-            linear_f32_from_linear_u8(srgba[3]),
-        )
-    }
-
-    /// From `sRGBA` without premultiplied alpha
-    pub fn from_srgba_unmultiplied(srgba: [u8; 4]) -> Self {
-        Self::from_rgba_unmultiplied(
-            linear_f32_from_gamma_u8(srgba[0]),
-            linear_f32_from_gamma_u8(srgba[1]),
-            linear_f32_from_gamma_u8(srgba[2]),
-            linear_f32_from_linear_u8(srgba[3]),
-        )
-    }
-
-    /// From linear RGBA with premultiplied alpha
-    pub fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
-        #![allow(clippy::many_single_char_names)]
-        if a == 0.0 {
-            if r == 0.0 && b == 0.0 && a == 0.0 {
-                Hsva::default()
-            } else {
-                Hsva::from_additive_rgb([r, g, b])
-            }
-        } else {
-            let (h, s, v) = hsv_from_rgb([r / a, g / a, b / a]);
-            Hsva { h, s, v, a }
-        }
-    }
-
-    /// From linear RGBA without premultiplied alpha
-    pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
-        #![allow(clippy::many_single_char_names)]
-        let (h, s, v) = hsv_from_rgb([r, g, b]);
-        Hsva { h, s, v, a }
-    }
-
-    pub fn from_additive_rgb(rgb: [f32; 3]) -> Self {
-        let (h, s, v) = hsv_from_rgb(rgb);
-        Hsva {
-            h,
-            s,
-            v,
-            a: -0.5, // anything negative is treated as additive
-        }
-    }
-
-    pub fn from_rgb(rgb: [f32; 3]) -> Self {
-        let (h, s, v) = hsv_from_rgb(rgb);
-        Hsva { h, s, v, a: 1.0 }
-    }
-
-    pub fn from_srgb([r, g, b]: [u8; 3]) -> Self {
-        Self::from_rgb([
-            linear_f32_from_gamma_u8(r),
-            linear_f32_from_gamma_u8(g),
-            linear_f32_from_gamma_u8(b),
-        ])
-    }
-
-    // ------------------------------------------------------------------------
-
-    pub fn to_opaque(self) -> Self {
-        Self { a: 1.0, ..self }
-    }
-
-    pub fn to_rgb(&self) -> [f32; 3] {
-        rgb_from_hsv((self.h, self.s, self.v))
-    }
-
-    pub fn to_srgb(&self) -> [u8; 3] {
-        let [r, g, b] = self.to_rgb();
-        [
-            gamma_u8_from_linear_f32(r),
-            gamma_u8_from_linear_f32(g),
-            gamma_u8_from_linear_f32(b),
-        ]
-    }
-
-    pub fn to_rgba_premultiplied(&self) -> [f32; 4] {
-        let [r, g, b, a] = self.to_rgba_unmultiplied();
-        let additive = a < 0.0;
-        if additive {
-            [r, g, b, 0.0]
-        } else {
-            [a * r, a * g, a * b, a]
-        }
-    }
-
-    /// Represents additive colors using a negative alpha.
-    pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
-        let Hsva { h, s, v, a } = *self;
-        let [r, g, b] = rgb_from_hsv((h, s, v));
-        [r, g, b, a]
-    }
-
-    pub fn to_srgba_premultiplied(&self) -> [u8; 4] {
-        let [r, g, b, a] = self.to_rgba_premultiplied();
-        [
-            gamma_u8_from_linear_f32(r),
-            gamma_u8_from_linear_f32(g),
-            gamma_u8_from_linear_f32(b),
-            linear_u8_from_linear_f32(a),
-        ]
-    }
-
-    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
-        let [r, g, b, a] = self.to_rgba_unmultiplied();
-        [
-            gamma_u8_from_linear_f32(r),
-            gamma_u8_from_linear_f32(g),
-            gamma_u8_from_linear_f32(b),
-            linear_u8_from_linear_f32(a.abs()),
-        ]
-    }
-}
-
-impl From<Hsva> for Rgba {
-    fn from(hsva: Hsva) -> Rgba {
-        Rgba(hsva.to_rgba_premultiplied())
-    }
-}
-
-impl From<Rgba> for Hsva {
-    fn from(rgba: Rgba) -> Hsva {
-        Self::from_rgba_premultiplied(rgba.0[0], rgba.0[1], rgba.0[2], rgba.0[3])
-    }
-}
-
-impl From<Hsva> for Color32 {
-    fn from(hsva: Hsva) -> Color32 {
-        Color32::from(Rgba::from(hsva))
-    }
-}
-
-impl From<Color32> for Hsva {
-    fn from(srgba: Color32) -> Hsva {
-        Hsva::from(Rgba::from(srgba))
-    }
-}
-
-/// All ranges in 0-1, rgb is linear.
-pub fn hsv_from_rgb([r, g, b]: [f32; 3]) -> (f32, f32, f32) {
-    #![allow(clippy::many_single_char_names)]
-    let min = r.min(g.min(b));
-    let max = r.max(g.max(b)); // value
-
-    let range = max - min;
-
-    let h = if max == min {
-        0.0 // hue is undefined
-    } else if max == r {
-        (g - b) / (6.0 * range)
-    } else if max == g {
-        (b - r) / (6.0 * range) + 1.0 / 3.0
-    } else {
-        // max == b
-        (r - g) / (6.0 * range) + 2.0 / 3.0
-    };
-    let h = (h + 1.0).fract(); // wrap
-    let s = if max == 0.0 { 0.0 } else { 1.0 - min / max };
-    (h, s, max)
-}
-
-/// All ranges in 0-1, rgb is linear.
-pub fn rgb_from_hsv((h, s, v): (f32, f32, f32)) -> [f32; 3] {
-    #![allow(clippy::many_single_char_names)]
-    let h = (h.fract() + 1.0).fract(); // wrap
-    let s = s.clamp(0.0, 1.0);
-
-    let f = h * 6.0 - (h * 6.0).floor();
-    let p = v * (1.0 - s);
-    let q = v * (1.0 - f * s);
-    let t = v * (1.0 - (1.0 - f) * s);
-
-    match (h * 6.0).floor() as i32 % 6 {
-        0 => [v, t, p],
-        1 => [q, v, p],
-        2 => [p, v, t],
-        3 => [p, q, v],
-        4 => [t, p, v],
-        5 => [v, p, q],
-        _ => unreachable!(),
-    }
-}
-
-#[test]
-#[ignore] // a bit expensive
-fn test_hsv_roundtrip() {
-    for r in 0..=255 {
-        for g in 0..=255 {
-            for b in 0..=255 {
-                let srgba = Color32::from_rgb(r, g, b);
-                let hsva = Hsva::from(srgba);
-                assert_eq!(srgba, Color32::from(hsva));
-            }
-        }
-    }
-}

crates/ecolor/src/hsva_gamma.rs

@@ -1,66 +0,0 @@
-use crate::{gamma_from_linear, linear_from_gamma, Color32, Hsva, Rgba};
-
-/// Like Hsva but with the `v` value (brightness) being gamma corrected
-/// so that it is somewhat perceptually even.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct HsvaGamma {
-    /// hue 0-1
-    pub h: f32,
-
-    /// saturation 0-1
-    pub s: f32,
-
-    /// value 0-1, in gamma-space (~perceptually even)
-    pub v: f32,
-
-    /// alpha 0-1. A negative value signifies an additive color (and alpha is ignored).
-    pub a: f32,
-}
-
-impl From<HsvaGamma> for Rgba {
-    fn from(hsvag: HsvaGamma) -> Rgba {
-        Hsva::from(hsvag).into()
-    }
-}
-
-impl From<HsvaGamma> for Color32 {
-    fn from(hsvag: HsvaGamma) -> Color32 {
-        Rgba::from(hsvag).into()
-    }
-}
-
-impl From<HsvaGamma> for Hsva {
-    fn from(hsvag: HsvaGamma) -> Hsva {
-        let HsvaGamma { h, s, v, a } = hsvag;
-        Hsva {
-            h,
-            s,
-            v: linear_from_gamma(v),
-            a,
-        }
-    }
-}
-
-impl From<Rgba> for HsvaGamma {
-    fn from(rgba: Rgba) -> HsvaGamma {
-        Hsva::from(rgba).into()
-    }
-}
-
-impl From<Color32> for HsvaGamma {
-    fn from(srgba: Color32) -> HsvaGamma {
-        Hsva::from(srgba).into()
-    }
-}
-
-impl From<Hsva> for HsvaGamma {
-    fn from(hsva: Hsva) -> HsvaGamma {
-        let Hsva { h, s, v, a } = hsva;
-        HsvaGamma {
-            h,
-            s,
-            v: gamma_from_linear(v),
-            a,
-        }
-    }
-}

crates/ecolor/src/lib.rs

@@ -1,173 +0,0 @@
-//! Color conversions and types.
-//!
-//! If you want a compact color representation, use [`Color32`].
-//! If you want to manipulate RGBA colors use [`Rgba`].
-//! If you want to manipulate colors in a way closer to how humans think about colors, use [`HsvaGamma`].
-//!
-//! ## Feature flags
-#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
-//!
-
-#![allow(clippy::wrong_self_convention)]
-
-#[cfg(feature = "cint")]
-mod cint_impl;
-#[cfg(feature = "cint")]
-pub use cint_impl::*;
-
-mod color32;
-pub use color32::*;
-
-mod hsva_gamma;
-pub use hsva_gamma::*;
-
-mod hsva;
-pub use hsva::*;
-
-#[cfg(feature = "color-hex")]
-mod hex_color_macro;
-
-mod rgba;
-pub use rgba::*;
-
-// ----------------------------------------------------------------------------
-// Color conversion:
-
-impl From<Color32> for Rgba {
-    fn from(srgba: Color32) -> Rgba {
-        Rgba([
-            linear_f32_from_gamma_u8(srgba.0[0]),
-            linear_f32_from_gamma_u8(srgba.0[1]),
-            linear_f32_from_gamma_u8(srgba.0[2]),
-            linear_f32_from_linear_u8(srgba.0[3]),
-        ])
-    }
-}
-
-impl From<Rgba> for Color32 {
-    fn from(rgba: Rgba) -> Color32 {
-        Color32([
-            gamma_u8_from_linear_f32(rgba.0[0]),
-            gamma_u8_from_linear_f32(rgba.0[1]),
-            gamma_u8_from_linear_f32(rgba.0[2]),
-            linear_u8_from_linear_f32(rgba.0[3]),
-        ])
-    }
-}
-
-/// gamma [0, 255] -> linear [0, 1].
-pub fn linear_f32_from_gamma_u8(s: u8) -> f32 {
-    if s <= 10 {
-        s as f32 / 3294.6
-    } else {
-        ((s as f32 + 14.025) / 269.025).powf(2.4)
-    }
-}
-
-/// linear [0, 255] -> linear [0, 1].
-/// Useful for alpha-channel.
-#[inline(always)]
-pub fn linear_f32_from_linear_u8(a: u8) -> f32 {
-    a as f32 / 255.0
-}
-
-/// linear [0, 1] -> gamma [0, 255] (clamped).
-/// Values outside this range will be clamped to the range.
-pub fn gamma_u8_from_linear_f32(l: f32) -> u8 {
-    if l <= 0.0 {
-        0
-    } else if l <= 0.0031308 {
-        fast_round(3294.6 * l)
-    } else if l <= 1.0 {
-        fast_round(269.025 * l.powf(1.0 / 2.4) - 14.025)
-    } else {
-        255
-    }
-}
-
-/// linear [0, 1] -> linear [0, 255] (clamped).
-/// Useful for alpha-channel.
-#[inline(always)]
-pub fn linear_u8_from_linear_f32(a: f32) -> u8 {
-    fast_round(a * 255.0)
-}
-
-fn fast_round(r: f32) -> u8 {
-    (r + 0.5).floor() as _ // rust does a saturating cast since 1.45
-}
-
-#[test]
-pub fn test_srgba_conversion() {
-    for b in 0..=255 {
-        let l = linear_f32_from_gamma_u8(b);
-        assert!(0.0 <= l && l <= 1.0);
-        assert_eq!(gamma_u8_from_linear_f32(l), b);
-    }
-}
-
-/// gamma [0, 1] -> linear [0, 1] (not clamped).
-/// Works for numbers outside this range (e.g. negative numbers).
-pub fn linear_from_gamma(gamma: f32) -> f32 {
-    if gamma < 0.0 {
-        -linear_from_gamma(-gamma)
-    } else if gamma <= 0.04045 {
-        gamma / 12.92
-    } else {
-        ((gamma + 0.055) / 1.055).powf(2.4)
-    }
-}
-
-/// linear [0, 1] -> gamma [0, 1] (not clamped).
-/// Works for numbers outside this range (e.g. negative numbers).
-pub fn gamma_from_linear(linear: f32) -> f32 {
-    if linear < 0.0 {
-        -gamma_from_linear(-linear)
-    } else if linear <= 0.0031308 {
-        12.92 * linear
-    } else {
-        1.055 * linear.powf(1.0 / 2.4) - 0.055
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-/// An assert that is only active when `epaint` is compiled with the `extra_asserts` feature
-/// or with the `extra_debug_asserts` feature in debug builds.
-#[macro_export]
-macro_rules! ecolor_assert {
-    ($($arg: tt)*) => {
-        if cfg!(any(
-            feature = "extra_asserts",
-            all(feature = "extra_debug_asserts", debug_assertions),
-        )) {
-            assert!($($arg)*);
-        }
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-/// Cheap and ugly.
-/// Made for graying out disabled `Ui`s.
-pub fn tint_color_towards(color: Color32, target: Color32) -> Color32 {
-    let [mut r, mut g, mut b, mut a] = color.to_array();
-
-    if a == 0 {
-        r /= 2;
-        g /= 2;
-        b /= 2;
-    } else if a < 170 {
-        // Cheapish and looks ok.
-        // Works for e.g. grid stripes.
-        let div = (2 * 255 / a as i32) as u8;
-        r = r / 2 + target.r() / div;
-        g = g / 2 + target.g() / div;
-        b = b / 2 + target.b() / div;
-        a /= 2;
-    } else {
-        r = r / 2 + target.r() / 2;
-        g = g / 2 + target.g() / 2;
-        b = b / 2 + target.b() / 2;
-    }
-    Color32::from_rgba_premultiplied(r, g, b, a)
-}

crates/ecolor/src/rgba.rs

@@ -1,266 +0,0 @@
-use crate::{
-    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
-    linear_u8_from_linear_f32,
-};
-
-/// 0-1 linear space `RGBA` color with premultiplied alpha.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
-pub struct Rgba(pub(crate) [f32; 4]);
-
-impl std::ops::Index<usize> for Rgba {
-    type Output = f32;
-
-    #[inline(always)]
-    fn index(&self, index: usize) -> &f32 {
-        &self.0[index]
-    }
-}
-
-impl std::ops::IndexMut<usize> for Rgba {
-    #[inline(always)]
-    fn index_mut(&mut self, index: usize) -> &mut f32 {
-        &mut self.0[index]
-    }
-}
-
-#[inline(always)]
-pub(crate) fn f32_hash<H: std::hash::Hasher>(state: &mut H, f: f32) {
-    if f == 0.0 {
-        state.write_u8(0);
-    } else if f.is_nan() {
-        state.write_u8(1);
-    } else {
-        use std::hash::Hash;
-        f.to_bits().hash(state);
-    }
-}
-
-#[allow(clippy::derive_hash_xor_eq)]
-impl std::hash::Hash for Rgba {
-    #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        crate::f32_hash(state, self.0[0]);
-        crate::f32_hash(state, self.0[1]);
-        crate::f32_hash(state, self.0[2]);
-        crate::f32_hash(state, self.0[3]);
-    }
-}
-
-impl Rgba {
-    pub const TRANSPARENT: Rgba = Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 0.0);
-    pub const BLACK: Rgba = Rgba::from_rgb(0.0, 0.0, 0.0);
-    pub const WHITE: Rgba = Rgba::from_rgb(1.0, 1.0, 1.0);
-    pub const RED: Rgba = Rgba::from_rgb(1.0, 0.0, 0.0);
-    pub const GREEN: Rgba = Rgba::from_rgb(0.0, 1.0, 0.0);
-    pub const BLUE: Rgba = Rgba::from_rgb(0.0, 0.0, 1.0);
-
-    #[inline(always)]
-    pub const fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
-        Self([r, g, b, a])
-    }
-
-    #[inline(always)]
-    pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
-        Self([r * a, g * a, b * a, a])
-    }
-
-    #[inline(always)]
-    pub fn from_srgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
-        let r = linear_f32_from_gamma_u8(r);
-        let g = linear_f32_from_gamma_u8(g);
-        let b = linear_f32_from_gamma_u8(b);
-        let a = linear_f32_from_linear_u8(a);
-        Self::from_rgba_premultiplied(r, g, b, a)
-    }
-
-    #[inline(always)]
-    pub fn from_srgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
-        let r = linear_f32_from_gamma_u8(r);
-        let g = linear_f32_from_gamma_u8(g);
-        let b = linear_f32_from_gamma_u8(b);
-        let a = linear_f32_from_linear_u8(a);
-        Self::from_rgba_premultiplied(r * a, g * a, b * a, a)
-    }
-
-    #[inline(always)]
-    pub const fn from_rgb(r: f32, g: f32, b: f32) -> Self {
-        Self([r, g, b, 1.0])
-    }
-
-    #[inline(always)]
-    pub const fn from_gray(l: f32) -> Self {
-        Self([l, l, l, 1.0])
-    }
-
-    pub fn from_luminance_alpha(l: f32, a: f32) -> Self {
-        crate::ecolor_assert!(0.0 <= l && l <= 1.0);
-        crate::ecolor_assert!(0.0 <= a && a <= 1.0);
-        Self([l * a, l * a, l * a, a])
-    }
-
-    /// Transparent black
-    #[inline(always)]
-    pub fn from_black_alpha(a: f32) -> Self {
-        crate::ecolor_assert!(0.0 <= a && a <= 1.0);
-        Self([0.0, 0.0, 0.0, a])
-    }
-
-    /// Transparent white
-    #[inline(always)]
-    pub fn from_white_alpha(a: f32) -> Self {
-        crate::ecolor_assert!(0.0 <= a && a <= 1.0, "a: {}", a);
-        Self([a, a, a, a])
-    }
-
-    /// Return an additive version of this color (alpha = 0)
-    #[inline(always)]
-    pub fn additive(self) -> Self {
-        let [r, g, b, _] = self.0;
-        Self([r, g, b, 0.0])
-    }
-
-    /// Multiply with e.g. 0.5 to make us half transparent
-    #[inline(always)]
-    pub fn multiply(self, alpha: f32) -> Self {
-        Self([
-            alpha * self[0],
-            alpha * self[1],
-            alpha * self[2],
-            alpha * self[3],
-        ])
-    }
-
-    #[inline(always)]
-    pub fn r(&self) -> f32 {
-        self.0[0]
-    }
-
-    #[inline(always)]
-    pub fn g(&self) -> f32 {
-        self.0[1]
-    }
-
-    #[inline(always)]
-    pub fn b(&self) -> f32 {
-        self.0[2]
-    }
-
-    #[inline(always)]
-    pub fn a(&self) -> f32 {
-        self.0[3]
-    }
-
-    /// How perceptually intense (bright) is the color?
-    #[inline]
-    pub fn intensity(&self) -> f32 {
-        0.3 * self.r() + 0.59 * self.g() + 0.11 * self.b()
-    }
-
-    /// Returns an opaque version of self
-    pub fn to_opaque(&self) -> Self {
-        if self.a() == 0.0 {
-            // Additive or fully transparent black.
-            Self::from_rgb(self.r(), self.g(), self.b())
-        } else {
-            // un-multiply alpha:
-            Self::from_rgb(
-                self.r() / self.a(),
-                self.g() / self.a(),
-                self.b() / self.a(),
-            )
-        }
-    }
-
-    /// Premultiplied RGBA
-    #[inline(always)]
-    pub fn to_array(&self) -> [f32; 4] {
-        [self.r(), self.g(), self.b(), self.a()]
-    }
-
-    /// Premultiplied RGBA
-    #[inline(always)]
-    pub fn to_tuple(&self) -> (f32, f32, f32, f32) {
-        (self.r(), self.g(), self.b(), self.a())
-    }
-
-    /// unmultiply the alpha
-    pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
-        let a = self.a();
-        if a == 0.0 {
-            // Additive, let's assume we are black
-            self.0
-        } else {
-            [self.r() / a, self.g() / a, self.b() / a, a]
-        }
-    }
-
-    /// unmultiply the alpha
-    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
-        let [r, g, b, a] = self.to_rgba_unmultiplied();
-        [
-            gamma_u8_from_linear_f32(r),
-            gamma_u8_from_linear_f32(g),
-            gamma_u8_from_linear_f32(b),
-            linear_u8_from_linear_f32(a.abs()),
-        ]
-    }
-}
-
-impl std::ops::Add for Rgba {
-    type Output = Rgba;
-
-    #[inline(always)]
-    fn add(self, rhs: Rgba) -> Rgba {
-        Rgba([
-            self[0] + rhs[0],
-            self[1] + rhs[1],
-            self[2] + rhs[2],
-            self[3] + rhs[3],
-        ])
-    }
-}
-
-impl std::ops::Mul<Rgba> for Rgba {
-    type Output = Rgba;
-
-    #[inline(always)]
-    fn mul(self, other: Rgba) -> Rgba {
-        Rgba([
-            self[0] * other[0],
-            self[1] * other[1],
-            self[2] * other[2],
-            self[3] * other[3],
-        ])
-    }
-}
-
-impl std::ops::Mul<f32> for Rgba {
-    type Output = Rgba;
-
-    #[inline(always)]
-    fn mul(self, factor: f32) -> Rgba {
-        Rgba([
-            self[0] * factor,
-            self[1] * factor,
-            self[2] * factor,
-            self[3] * factor,
-        ])
-    }
-}
-
-impl std::ops::Mul<Rgba> for f32 {
-    type Output = Rgba;
-
-    #[inline(always)]
-    fn mul(self, rgba: Rgba) -> Rgba {
-        Rgba([
-            self * rgba[0],
-            self * rgba[1],
-            self * rgba[2],
-            self * rgba[3],
-        ])
-    }
-}

crates/eframe/CHANGELOG.md

@@ -1,229 +0,0 @@
-# Changelog for eframe
-All notable changes to the `eframe` crate.
-
-NOTE: [`egui-winit`](../egui-winit/CHANGELOG.md), [`egui_glium`](../egui_glium/CHANGELOG.md), [`egui_glow`](../egui_glow/CHANGELOG.md),and [`egui-wgpu`](../egui-wgpu/CHANGELOG.md) have their own changelogs!
-
-
-## Unreleased
-
-
-## 0.21.3 - 2023-02-15
-* Fix typing the letter 'P' on web ([#2740](https://github.com/emilk/egui/pull/2740)).
-
-
-## 0.21.2 - 2023-02-12
-* Allow compiling `eframe` with `--no-default-features` ([#2728](https://github.com/emilk/egui/pull/2728)).
-
-
-## 0.21.1 - 2023-02-12
-* Fixed crash when native window position is in an invalid state, which could happen e.g. due to changes in monitor size or DPI ([#2722](https://github.com/emilk/egui/issues/2722)).
-
-
-## 0.21.0 - 2023-02-08 - Update to `winit` 0.28
-* ⚠️ BREAKING: `App::clear_color` now expects you to return a raw float array ([#2666](https://github.com/emilk/egui/pull/2666)).
-* The `screen_reader` feature has now been renamed `web_screen_reader` and only work on web. On other platforms, use the `accesskit` feature flag instead ([#2669](https://github.com/emilk/egui/pull/2669)).
-
-#### Desktop/Native:
-* `eframe::run_native` now returns a `Result` ([#2433](https://github.com/emilk/egui/pull/2433)).
-* Update to `winit` 0.28, adding support for mac trackpad zoom ([#2654](https://github.com/emilk/egui/pull/2654)).
-* Fix bug where the cursor could get stuck using the wrong icon.
-* `NativeOptions::transparent` now works with the wgpu backend ([#2684](https://github.com/emilk/egui/pull/2684)).
-* Add `Frame::set_minimized` and `set_maximized` ([#2292](https://github.com/emilk/egui/pull/2292), [#2672](https://github.com/emilk/egui/pull/2672)).
-* Fixed persistence of native window position on Windows OS ([#2583](https://github.com/emilk/egui/issues/2583)).
-
-#### Web:
-* Prevent ctrl-P/cmd-P from opening the print dialog ([#2598](https://github.com/emilk/egui/pull/2598)).
-
-
-## 0.20.1 - 2022-12-11
-* Fix [docs.rs](https://docs.rs/eframe) build ([#2420](https://github.com/emilk/egui/pull/2420)).
-
-
-## 0.20.0 - 2022-12-08 - AccessKit integration and `wgpu` web support
-* MSRV (Minimum Supported Rust Version) is now `1.65.0` ([#2314](https://github.com/emilk/egui/pull/2314)).
-* Allow empty textures with the glow renderer.
-
-#### Desktop/Native:
-* Don't repaint when just moving window ([#1980](https://github.com/emilk/egui/pull/1980)).
-* Added `NativeOptions::event_loop_builder` hook for apps to change platform specific event loop options ([#1952](https://github.com/emilk/egui/pull/1952)).
-* Enabled deferred render state initialization to support Android ([#1952](https://github.com/emilk/egui/pull/1952)).
-* Added `shader_version` to `NativeOptions` for cross compiling support on different target OpenGL | ES versions (on native `glow` renderer only) ([#1993](https://github.com/emilk/egui/pull/1993)).
-* Fix: app state is now saved when user presses Cmd-Q on Mac ([#2013](https://github.com/emilk/egui/pull/2013)).
-* Added `center` to `NativeOptions` and `monitor_size` to `WindowInfo` on desktop ([#2035](https://github.com/emilk/egui/pull/2035)).
-* Improve IME support ([#2046](https://github.com/emilk/egui/pull/2046)).
-* Added mouse-passthrough option ([#2080](https://github.com/emilk/egui/pull/2080)).
-* Added `NativeOptions::fullsize_content` option on Mac to build titlebar-less windows with floating window controls ([#2049](https://github.com/emilk/egui/pull/2049)).
-* Wgpu device/adapter/surface creation has now various configuration options exposed via `NativeOptions/WebOptions::wgpu_options` ([#2207](https://github.com/emilk/egui/pull/2207)).
-* Fix: Make sure that `native_pixels_per_point` is updated ([#2256](https://github.com/emilk/egui/pull/2256)).
-* Added optional, but enabled by default, integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
-* Fix: Less flickering on resize on Windows ([#2280](https://github.com/emilk/egui/pull/2280)).
-
-#### Web:
-* ⚠️ BREAKING: `start_web` is a now `async` ([#2107](https://github.com/emilk/egui/pull/2107)).
-* Web: You can now use WebGL on top of `wgpu` by enabling the `wgpu` feature (and disabling `glow` via disabling default features) ([#2107](https://github.com/emilk/egui/pull/2107)).
-* Web: Add `WebInfo::user_agent` ([#2202](https://github.com/emilk/egui/pull/2202)).
-* Web: you can access your application from JS using `AppRunner::app_mut`. See `crates/egui_demo_app/src/lib.rs` ([#1886](https://github.com/emilk/egui/pull/1886)).
-
-
-## 0.19.0 - 2022-08-20
-* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
-* Added `wgpu` rendering backed ([#1564](https://github.com/emilk/egui/pull/1564)):
-  * Added features `wgpu` and `glow`.
-  * Added `NativeOptions::renderer` to switch between the rendering backends.
-* `egui_glow`: remove calls to `gl.get_error` in release builds to speed up rendering ([#1583](https://github.com/emilk/egui/pull/1583)).
-* Added `App::post_rendering` for e.g. reading the framebuffer ([#1591](https://github.com/emilk/egui/pull/1591)).
-* Use `Arc` for `glow::Context` instead of `Rc` ([#1640](https://github.com/emilk/egui/pull/1640)).
-* Fixed bug where the result returned from `App::on_exit_event` would sometimes be ignored ([#1696](https://github.com/emilk/egui/pull/1696)).
-* Added `NativeOptions::follow_system_theme` and `NativeOptions::default_theme` ([#1726](https://github.com/emilk/egui/pull/1726)).
-* Selectively expose parts of the API based on target arch (`wasm32` or not) ([#1867](https://github.com/emilk/egui/pull/1867)).
-
-#### Desktop/Native:
-* Fixed clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
-* Added ability to read window position and size with `frame.info().window_info` ([#1617](https://github.com/emilk/egui/pull/1617)).
-* Allow running on native without hardware accelerated rendering. Change with `NativeOptions::hardware_acceleration` ([#1681](https://github.com/emilk/egui/pull/1681), [#1693](https://github.com/emilk/egui/pull/1693)).
-* Fixed window position persistence ([#1745](https://github.com/emilk/egui/pull/1745)).
-* Fixed mouse cursor change on Linux ([#1747](https://github.com/emilk/egui/pull/1747)).
-* Added `Frame::set_visible` ([#1808](https://github.com/emilk/egui/pull/1808)).
-* Added fullscreen support ([#1866](https://github.com/emilk/egui/pull/1866)).
-* You can now continue execution after closing the native desktop window ([#1889](https://github.com/emilk/egui/pull/1889)).
-* `Frame::quit` has been renamed to `Frame::close` and `App::on_exit_event` is now `App::on_close_event` ([#1943](https://github.com/emilk/egui/pull/1943)).
-
-#### Web:
-* Added ability to stop/re-run web app from JavaScript. ⚠️ You need to update your CSS with `html, body: { height: 100%; width: 100%; }` ([#1803](https://github.com/emilk/egui/pull/1650)).
-* Added `WebOptions::follow_system_theme` and `WebOptions::default_theme` ([#1726](https://github.com/emilk/egui/pull/1726)).
-* Added option to select WebGL version ([#1803](https://github.com/emilk/egui/pull/1803)).
-
-
-## 0.18.0 - 2022-04-30
-* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
-* Removed `eframe::epi` - everything is now in `eframe` (`eframe::App`, `eframe::Frame` etc) ([#1545](https://github.com/emilk/egui/pull/1545)).
-* Removed `Frame::request_repaint` - just call `egui::Context::request_repaint` for the same effect ([#1366](https://github.com/emilk/egui/pull/1366)).
-* Changed app creation/setup ([#1363](https://github.com/emilk/egui/pull/1363)):
-  * Removed `App::setup` and `App::name`.
-  * Provide `CreationContext` when creating app with egui context, storage, integration info and glow context.
-  * Change interface of `run_native` and `start_web`.
-* Added `Frame::storage()` and `Frame::storage_mut()` ([#1418](https://github.com/emilk/egui/pull/1418)).
-  * You can now load/save state in `App::update`
-  * Changed `App::update` to take `&mut Frame` instead of `&Frame`.
-  * `Frame` is no longer `Clone` or `Sync`.
-* Added `glow` (OpenGL) context to `Frame` ([#1425](https://github.com/emilk/egui/pull/1425)).
-
-#### Desktop/Native:
-* Remove the `egui_glium` feature. `eframe` will now always use `egui_glow` as the native backend ([#1357](https://github.com/emilk/egui/pull/1357)).
-* Change default for `NativeOptions::drag_and_drop_support` to `true` ([#1329](https://github.com/emilk/egui/pull/1329)).
-* Added new `NativeOptions`: `vsync`, `multisampling`, `depth_buffer`, `stencil_buffer`.
-* `dark-light` (dark mode detection) is now an opt-in feature ([#1437](https://github.com/emilk/egui/pull/1437)).
-* Fixed potential scale bug when DPI scaling changes (e.g. when dragging a  window between different displays) ([#1441](https://github.com/emilk/egui/pull/1441)).
-* Added new feature `puffin` to add [`puffin profiler`](https://github.com/EmbarkStudios/puffin) scopes ([#1483](https://github.com/emilk/egui/pull/1483)).
-* Moved app persistence to a background thread, allowing for smoother frame rates (on native).
-* Added `Frame::set_window_pos` ([#1505](https://github.com/emilk/egui/pull/1505)).
-
-#### Web:
-* Use full browser width by default ([#1378](https://github.com/emilk/egui/pull/1378)).
-* egui code will no longer be called after panic ([#1306](https://github.com/emilk/egui/pull/1306)).
-
-
-## 0.17.0 - 2022-02-22
-* Removed `Frame::alloc_texture`. Use `egui::Context::load_texture` instead ([#1110](https://github.com/emilk/egui/pull/1110)).
-* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
-* Log using the `tracing` crate. Log to stdout by adding `tracing_subscriber::fmt::init();` to your `main` ([#1192](https://github.com/emilk/egui/pull/1192)).
-
-#### Desktop/Native:
-* The default native backend is now `egui_glow` (instead of `egui_glium`) ([#1020](https://github.com/emilk/egui/pull/1020)).
-* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
-* Fixed horizontal scrolling direction on Linux.
-* Added `App::on_exit_event` ([#1038](https://github.com/emilk/egui/pull/1038))
-* Added `NativeOptions::initial_window_pos`.
-* Fixed `enable_drag` for Windows OS ([#1108](https://github.com/emilk/egui/pull/1108)).
-
-#### Web:
-* The default web painter is now `egui_glow` (instead of WebGL) ([#1020](https://github.com/emilk/egui/pull/1020)).
-* Fixed glow failure on Chromium ([#1092](https://github.com/emilk/egui/pull/1092)).
-* Updated `eframe::IntegrationInfo::web_location_hash` on `hashchange` event ([#1140](https://github.com/emilk/egui/pull/1140)).
-* Expose all parts of the location/url in `frame.info().web_info` ([#1258](https://github.com/emilk/egui/pull/1258)).
-
-
-## 0.16.0 - 2021-12-29
-* `Frame` can now be cloned, saved, and passed to background threads ([#999](https://github.com/emilk/egui/pull/999)).
-* Added `Frame::request_repaint` to replace `repaint_signal` ([#999](https://github.com/emilk/egui/pull/999)).
-* Added `Frame::alloc_texture/free_texture` to replace `tex_allocator` ([#999](https://github.com/emilk/egui/pull/999)).
-
-#### Web:
-* Fixed [dark rendering in WebKitGTK](https://github.com/emilk/egui/issues/794) ([#888](https://github.com/emilk/egui/pull/888/)).
-* Added feature `glow` to switch to a [`glow`](https://github.com/grovesNL/glow) based painter ([#868](https://github.com/emilk/egui/pull/868)).
-
-
-## 0.15.0 - 2021-10-24
-* `Frame` now provides `set_window_title` to set window title dynamically ([#828](https://github.com/emilk/egui/pull/828)).
-* `Frame` now provides `set_decorations` to set whether to show window decorations.
-* Remove "http" feature (use https://github.com/emilk/ehttp instead!).
-* Added `App::persist_native_window` and `App::persist_egui_memory` to control what gets persisted.
-
-#### Desktop/Native:
-* Increase native scroll speed.
-* Added new backend `egui_glow` as an alternative to `egui_glium`. Enable with `default-features = false, features = ["default_fonts", "egui_glow"]`.
-
-#### Web:
-* Implement `eframe::NativeTexture` trait for the WebGL painter.
-* Deprecate `Painter::register_webgl_texture.
-* Fixed multiline paste.
-* Fixed painting with non-opaque backgrounds.
-* Improve text input on mobile and for IME.
-
-
-## 0.14.0 - 2021-08-24
-* Added dragging and dropping files into egui.
-* Improve http fetch API.
-* `run_native` now returns when the app is closed.
-* Web: Made text thicker and less pixelated.
-
-
-## 0.13.1 - 2021-06-24
-* Fixed `http` feature flag and docs
-
-
-## 0.13.0 - 2021-06-24
-* `App::setup` now takes a `Frame` and `Storage` by argument.
-* `App::load` has been removed. Implement `App::setup` instead.
-* Web: Default to light visuals unless the system reports a preference for dark mode.
-* Web: Improve alpha blending, making fonts look much better (especially in light mode)
-* Web: Fix double-paste bug
-
-
-## 0.12.0 - 2021-05-10
-* Moved options out of `trait App` into new `NativeOptions`.
-* Added option for `always_on_top`.
-* Web: Scroll faster when scrolling with mouse wheel.
-
-
-## 0.11.0 - 2021-04-05
-* You can now turn your window transparent with the `App::transparent` option.
-* You can now disable window decorations with the `App::decorated` option.
-* Web: [Fix mobile and IME text input](https://github.com/emilk/egui/pull/253)
-* Web: Hold down a modifier key when clicking a link to open it in a new tab.
-
-Contributors: [n2](https://github.com/n2)
-
-
-## 0.10.0 - 2021-02-28
-* [You can now set your own app icons](https://github.com/emilk/egui/pull/193).
-* You can control the initial size of the native window with `App::initial_window_size`.
-* You can control the maximum egui web canvas size with `App::max_size_points`.
-* `Frame::tex_allocator()` no longer returns an `Option` (there is always a texture allocator).
-
-
-## 0.9.0 - 2021-02-07
-* [Added support for HTTP body](https://github.com/emilk/egui/pull/139).
-* Web: Right-clicks will no longer open browser context menu.
-* Web: Fix a bug where one couldn't select items in a combo box on a touch screen.
-
-
-## 0.8.0 - 2021-01-17
-* Simplify `TextureAllocator` interface.
-* WebGL2 is now supported, with improved texture sampler. WebGL1 will be used as a fallback.
-* Web: Slightly improved alpha-blending (work-around for non-existing linear-space blending).
-* Web: Call `prevent_default` for arrow keys when entering text
-
-
-## 0.7.0 - 2021-01-04
-* Initial release of `eframe`

crates/eframe/Cargo.toml

@@ -1,169 +0,0 @@
-[package]
-name = "eframe"
-version = "0.21.3"
-authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
-description = "egui framework - write GUI apps that compiles to web and/or natively"
-edition = "2021"
-rust-version = "1.65"
-homepage = "https://github.com/emilk/egui/tree/master/crates/eframe"
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/eframe"
-categories = ["gui", "game-development"]
-keywords = ["egui", "gui", "gamedev"]
-include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
-
-[package.metadata.docs.rs]
-all-features = true
-targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
-
-[lib]
-
-
-[features]
-default = ["accesskit", "default_fonts", "glow"]
-
-## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
-accesskit = ["egui/accesskit", "egui-winit/accesskit"]
-
-## Detect dark mode system preference using [`dark-light`](https://docs.rs/dark-light).
-##
-## See also [`NativeOptions::follow_system_theme`] and [`NativeOptions::default_theme`].
-dark-light = ["dep:dark-light"]
-
-## If set, egui will use `include_bytes!` to bundle some fonts.
-## If you plan on specifying your own fonts you may disable this feature.
-default_fonts = ["egui/default_fonts"]
-
-## Use [`glow`](https://github.com/grovesNL/glow) for painting, via [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow).
-glow = ["dep:glow", "dep:egui_glow", "dep:glutin", "dep:glutin-winit"]
-
-## Enable saving app state to disk.
-persistence = [
-  "directories-next",
-  "egui-winit/serde",
-  "egui/persistence",
-  "ron",
-  "serde",
-]
-
-## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
-##
-## Only enabled on native, because of the low resolution (1ms) of time keeping in browsers.
-## `eframe` will call `puffin::GlobalProfiler::lock().new_frame()` for you
-puffin = ["dep:puffin", "egui_glow?/puffin", "egui-wgpu?/puffin"]
-
-## Enable screen reader support (requires `ctx.options_mut(|o| o.screen_reader = true);`) on web.
-##
-## For other platforms, use the "accesskit" feature instead.
-web_screen_reader = ["tts"]
-
-## If set, eframe will look for the env-var `EFRAME_SCREENSHOT_TO` and write a screenshot to that location, and then quit.
-## This is used to generate images for the examples.
-__screenshot = ["dep:image"]
-
-## Use [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu)).
-## This overrides the `glow` feature.
-wgpu = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster"]
-
-
-[dependencies]
-egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
-  "bytemuck",
-  "tracing",
-] }
-thiserror = "1.0.37"
-tracing = { version = "0.1", default-features = false, features = ["std"] }
-
-#! ### Optional dependencies
-## Enable this when generating docs.
-document-features = { version = "0.2", optional = true }
-
-egui_glow = { version = "0.21.0", path = "../egui_glow", optional = true, default-features = false }
-glow = { version = "0.12", optional = true }
-ron = { version = "0.8", optional = true, features = ["integer128"] }
-serde = { version = "1", optional = true, features = ["derive"] }
-
-# -------------------------------------------
-# native:
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-egui-winit = { version = "0.21.1", path = "../egui-winit", default-features = false, features = [
-  "clipboard",
-  "links",
-] }
-raw-window-handle = { version = "0.5.0" }
-winit = "0.28.1"
-
-# optional native:
-dark-light = { version = "1.0", optional = true }
-directories-next = { version = "2", optional = true }
-egui-wgpu = { version = "0.21.0", path = "../egui-wgpu", optional = true, features = [
-  "winit",
-] } # if wgpu is used, use it with winit
-pollster = { version = "0.3", optional = true } # needed for wgpu
-
-# we can expose these to user so that they can select which backends they want to enable to avoid compiling useless deps.
-# this can be done at the same time we expose x11/wayland features of winit crate.
-glutin = { version = "0.30", optional = true }
-glutin-winit = { version = "0.3.0", optional = true }
-image = { version = "0.24", optional = true, default-features = false, features = [
-  "png",
-] }
-puffin = { version = "0.14", optional = true }
-wgpu = { version = "0.15.0", optional = true }
-
-# -------------------------------------------
-# web:
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-bytemuck = "1.7"
-js-sys = "0.3"
-percent-encoding = "2.1"
-wasm-bindgen = "=0.2.84"
-wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3.58", features = [
-  "BinaryType",
-  "Blob",
-  "Clipboard",
-  "ClipboardEvent",
-  "CompositionEvent",
-  "console",
-  "CssStyleDeclaration",
-  "DataTransfer",
-  "DataTransferItem",
-  "DataTransferItemList",
-  "Document",
-  "DomRect",
-  "DragEvent",
-  "Element",
-  "Event",
-  "EventListener",
-  "EventTarget",
-  "ExtSRgb",
-  "File",
-  "FileList",
-  "FocusEvent",
-  "HtmlCanvasElement",
-  "HtmlElement",
-  "HtmlInputElement",
-  "InputEvent",
-  "KeyboardEvent",
-  "Location",
-  "MediaQueryList",
-  "MouseEvent",
-  "Navigator",
-  "Performance",
-  "Storage",
-  "Touch",
-  "TouchEvent",
-  "TouchList",
-  "WebGl2RenderingContext",
-  "WebglDebugRendererInfo",
-  "WebGlRenderingContext",
-  "WheelEvent",
-  "Window",
-] }
-
-# optional web:
-egui-wgpu = { version = "0.21.0", path = "../egui-wgpu", optional = true } # if wgpu is used, use it without (!) winit
-tts = { version = "0.25", optional = true, default-features = false }
-wgpu = { version = "0.15.0", optional = true, features = ["webgl"] }

crates/eframe/src/web/web_painter.rs

@@ -1,29 +0,0 @@
-use wasm_bindgen::JsValue;
-
-/// Renderer for a browser canvas.
-/// As of writing we're not allowing to decide on the painter at runtime,
-/// therefore this trait is merely there for specifying and documenting the interface.
-pub(crate) trait WebPainter {
-    // Create a new web painter targeting a given canvas.
-    // fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String>
-    // where
-    //     Self: Sized;
-
-    /// Id of the canvas in use.
-    fn canvas_id(&self) -> &str;
-
-    /// Maximum size of a texture in one direction.
-    fn max_texture_side(&self) -> usize;
-
-    /// Update all internal textures and paint gui.
-    fn paint_and_update_textures(
-        &mut self,
-        clear_color: [f32; 4],
-        clipped_primitives: &[egui::ClippedPrimitive],
-        pixels_per_point: f32,
-        textures_delta: &egui::TexturesDelta,
-    ) -> Result<(), JsValue>;
-
-    /// Destroy all resources.
-    fn destroy(&mut self);
-}

crates/eframe/src/web/web_painter_glow.rs

@@ -1,184 +0,0 @@
-use wasm_bindgen::JsCast;
-use wasm_bindgen::JsValue;
-use web_sys::HtmlCanvasElement;
-
-use egui_glow::glow;
-
-use crate::{WebGlContextOption, WebOptions};
-
-use super::web_painter::WebPainter;
-
-pub(crate) struct WebPainterGlow {
-    canvas: HtmlCanvasElement,
-    canvas_id: String,
-    painter: egui_glow::Painter,
-}
-
-impl WebPainterGlow {
-    pub fn gl(&self) -> &std::sync::Arc<glow::Context> {
-        self.painter.gl()
-    }
-
-    pub async fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String> {
-        let canvas = super::canvas_element_or_die(canvas_id);
-
-        let (gl, shader_prefix) =
-            init_glow_context_from_canvas(&canvas, options.webgl_context_option)?;
-        let gl = std::sync::Arc::new(gl);
-
-        let painter = egui_glow::Painter::new(gl, shader_prefix, None)
-            .map_err(|error| format!("Error starting glow painter: {}", error))?;
-
-        Ok(Self {
-            canvas,
-            canvas_id: canvas_id.to_owned(),
-            painter,
-        })
-    }
-}
-
-impl WebPainter for WebPainterGlow {
-    fn max_texture_side(&self) -> usize {
-        self.painter.max_texture_side()
-    }
-
-    fn canvas_id(&self) -> &str {
-        &self.canvas_id
-    }
-
-    fn paint_and_update_textures(
-        &mut self,
-        clear_color: [f32; 4],
-        clipped_primitives: &[egui::ClippedPrimitive],
-        pixels_per_point: f32,
-        textures_delta: &egui::TexturesDelta,
-    ) -> Result<(), JsValue> {
-        let canvas_dimension = [self.canvas.width(), self.canvas.height()];
-
-        for (id, image_delta) in &textures_delta.set {
-            self.painter.set_texture(*id, image_delta);
-        }
-
-        egui_glow::painter::clear(self.painter.gl(), canvas_dimension, clear_color);
-        self.painter
-            .paint_primitives(canvas_dimension, pixels_per_point, clipped_primitives);
-
-        for &id in &textures_delta.free {
-            self.painter.free_texture(id);
-        }
-
-        Ok(())
-    }
-
-    fn destroy(&mut self) {
-        self.painter.destroy();
-    }
-}
-
-/// Returns glow context and shader prefix.
-fn init_glow_context_from_canvas(
-    canvas: &HtmlCanvasElement,
-    options: WebGlContextOption,
-) -> Result<(glow::Context, &'static str), String> {
-    let result = match options {
-        // Force use WebGl1
-        WebGlContextOption::WebGl1 => init_webgl1(canvas),
-        // Force use WebGl2
-        WebGlContextOption::WebGl2 => init_webgl2(canvas),
-        // Trying WebGl2 first
-        WebGlContextOption::BestFirst => init_webgl2(canvas).or_else(|| init_webgl1(canvas)),
-        // Trying WebGl1 first (useful for testing).
-        WebGlContextOption::CompatibilityFirst => {
-            init_webgl1(canvas).or_else(|| init_webgl2(canvas))
-        }
-    };
-
-    if let Some(result) = result {
-        Ok(result)
-    } else {
-        Err("WebGL isn't supported".into())
-    }
-}
-
-fn init_webgl1(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
-    let gl1_ctx = canvas
-        .get_context("webgl")
-        .expect("Failed to query about WebGL2 context");
-
-    let gl1_ctx = gl1_ctx?;
-    tracing::debug!("WebGL1 selected.");
-
-    let gl1_ctx = gl1_ctx
-        .dyn_into::<web_sys::WebGlRenderingContext>()
-        .unwrap();
-
-    let shader_prefix = if webgl1_requires_brightening(&gl1_ctx) {
-        tracing::debug!("Enabling webkitGTK brightening workaround.");
-        "#define APPLY_BRIGHTENING_GAMMA"
-    } else {
-        ""
-    };
-
-    let gl = glow::Context::from_webgl1_context(gl1_ctx);
-
-    Some((gl, shader_prefix))
-}
-
-fn init_webgl2(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
-    let gl2_ctx = canvas
-        .get_context("webgl2")
-        .expect("Failed to query about WebGL2 context");
-
-    let gl2_ctx = gl2_ctx?;
-    tracing::debug!("WebGL2 selected.");
-
-    let gl2_ctx = gl2_ctx
-        .dyn_into::<web_sys::WebGl2RenderingContext>()
-        .unwrap();
-    let gl = glow::Context::from_webgl2_context(gl2_ctx);
-    let shader_prefix = "";
-
-    Some((gl, shader_prefix))
-}
-
-fn webgl1_requires_brightening(gl: &web_sys::WebGlRenderingContext) -> bool {
-    // See https://github.com/emilk/egui/issues/794
-
-    // detect WebKitGTK
-
-    // WebKitGTK use WebKit default unmasked vendor and renderer
-    // but safari use same vendor and renderer
-    // so exclude "Mac OS X" user-agent.
-    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
-    !user_agent.contains("Mac OS X") && is_safari_and_webkit_gtk(gl)
-}
-
-/// detecting Safari and `webkitGTK`.
-///
-/// Safari and `webkitGTK` use unmasked renderer :Apple GPU
-///
-/// If we detect safari or `webkitGTKs` returns true.
-///
-/// This function used to avoid displaying linear color with `sRGB` supported systems.
-fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {
-    // This call produces a warning in Firefox ("WEBGL_debug_renderer_info is deprecated in Firefox and will be removed.")
-    // but unless we call it we get errors in Chrome when we call `get_parameter` below.
-    // TODO(emilk): do something smart based on user agent?
-    if gl
-        .get_extension("WEBGL_debug_renderer_info")
-        .unwrap()
-        .is_some()
-    {
-        if let Ok(renderer) =
-            gl.get_parameter(web_sys::WebglDebugRendererInfo::UNMASKED_RENDERER_WEBGL)
-        {
-            if let Some(renderer) = renderer.as_string() {
-                if renderer.contains("Apple") {
-                    return true;
-                }
-            }
-        }
-    }
-
-    false
-}

crates/eframe/src/web/web_painter_wgpu.rs

@@ -1,282 +0,0 @@
-use std::sync::Arc;
-
-use wasm_bindgen::JsValue;
-use web_sys::HtmlCanvasElement;
-
-use egui::mutex::RwLock;
-use egui_wgpu::{renderer::ScreenDescriptor, RenderState, SurfaceErrorAction};
-
-use crate::WebOptions;
-
-use super::web_painter::WebPainter;
-
-pub(crate) struct WebPainterWgpu {
-    canvas: HtmlCanvasElement,
-    canvas_id: String,
-    surface: wgpu::Surface,
-    surface_configuration: wgpu::SurfaceConfiguration,
-    limits: wgpu::Limits,
-    render_state: Option<RenderState>,
-    on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
-    depth_format: Option<wgpu::TextureFormat>,
-    depth_texture_view: Option<wgpu::TextureView>,
-}
-
-impl WebPainterWgpu {
-    #[allow(unused)] // only used if `wgpu` is the only active feature.
-    pub fn render_state(&self) -> Option<RenderState> {
-        self.render_state.clone()
-    }
-
-    pub fn generate_depth_texture_view(
-        &self,
-        render_state: &RenderState,
-        width_in_pixels: u32,
-        height_in_pixels: u32,
-    ) -> Option<wgpu::TextureView> {
-        let device = &render_state.device;
-        self.depth_format.map(|depth_format| {
-            device
-                .create_texture(&wgpu::TextureDescriptor {
-                    label: Some("egui_depth_texture"),
-                    size: wgpu::Extent3d {
-                        width: width_in_pixels,
-                        height: height_in_pixels,
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: depth_format,
-                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-                    view_formats: &[depth_format],
-                })
-                .create_view(&wgpu::TextureViewDescriptor::default())
-        })
-    }
-
-    #[allow(unused)] // only used if `wgpu` is the only active feature.
-    pub async fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String> {
-        tracing::debug!("Creating wgpu painter");
-
-        let canvas = super::canvas_element_or_die(canvas_id);
-
-        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-            backends: options.wgpu_options.backends,
-            dx12_shader_compiler: Default::default(),
-        });
-        let surface = instance
-            .create_surface_from_canvas(&canvas)
-            .map_err(|err| format!("failed to create wgpu surface: {err}"))?;
-
-        let adapter = instance
-            .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: options.wgpu_options.power_preference,
-                force_fallback_adapter: false,
-                compatible_surface: None,
-            })
-            .await
-            .ok_or_else(|| "No suitable GPU adapters found on the system".to_owned())?;
-
-        let (device, queue) = adapter
-            .request_device(
-                &options.wgpu_options.device_descriptor,
-                None, // Capture doesn't work in the browser environment.
-            )
-            .await
-            .map_err(|err| format!("Failed to find wgpu device: {}", err))?;
-
-        let target_format =
-            egui_wgpu::preferred_framebuffer_format(&surface.get_capabilities(&adapter).formats);
-
-        let depth_format = options.wgpu_options.depth_format;
-        let renderer = egui_wgpu::Renderer::new(&device, target_format, depth_format, 1);
-        let render_state = RenderState {
-            device: Arc::new(device),
-            queue: Arc::new(queue),
-            target_format,
-            renderer: Arc::new(RwLock::new(renderer)),
-        };
-
-        let surface_configuration = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: target_format,
-            width: 0,
-            height: 0,
-            present_mode: options.wgpu_options.present_mode,
-            alpha_mode: wgpu::CompositeAlphaMode::Auto,
-            view_formats: vec![target_format],
-        };
-
-        tracing::debug!("wgpu painter initialized.");
-
-        Ok(Self {
-            canvas,
-            canvas_id: canvas_id.to_owned(),
-            render_state: Some(render_state),
-            surface,
-            surface_configuration,
-            depth_format,
-            depth_texture_view: None,
-            limits: options.wgpu_options.device_descriptor.limits.clone(),
-            on_surface_error: options.wgpu_options.on_surface_error.clone(),
-        })
-    }
-}
-
-impl WebPainter for WebPainterWgpu {
-    fn canvas_id(&self) -> &str {
-        &self.canvas_id
-    }
-
-    fn max_texture_side(&self) -> usize {
-        self.limits.max_texture_dimension_2d as _
-    }
-
-    fn paint_and_update_textures(
-        &mut self,
-        clear_color: [f32; 4],
-        clipped_primitives: &[egui::ClippedPrimitive],
-        pixels_per_point: f32,
-        textures_delta: &egui::TexturesDelta,
-    ) -> Result<(), JsValue> {
-        let size_in_pixels = [self.canvas.width(), self.canvas.height()];
-
-        let render_state = if let Some(render_state) = &self.render_state {
-            render_state
-        } else {
-            return Err(JsValue::from_str(
-                "Can't paint, wgpu renderer was already disposed",
-            ));
-        };
-
-        let mut encoder =
-            render_state
-                .device
-                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                    label: Some("egui_webpainter_paint_and_update_textures"),
-                });
-
-        // Upload all resources for the GPU.
-        let screen_descriptor = ScreenDescriptor {
-            size_in_pixels,
-            pixels_per_point,
-        };
-
-        let user_cmd_bufs = {
-            let mut renderer = render_state.renderer.write();
-            for (id, image_delta) in &textures_delta.set {
-                renderer.update_texture(
-                    &render_state.device,
-                    &render_state.queue,
-                    *id,
-                    image_delta,
-                );
-            }
-
-            renderer.update_buffers(
-                &render_state.device,
-                &render_state.queue,
-                &mut encoder,
-                clipped_primitives,
-                &screen_descriptor,
-            )
-        };
-
-        // Resize surface if needed
-        let is_zero_sized_surface = size_in_pixels[0] == 0 || size_in_pixels[1] == 0;
-        let frame = if is_zero_sized_surface {
-            None
-        } else {
-            if size_in_pixels[0] != self.surface_configuration.width
-                || size_in_pixels[1] != self.surface_configuration.height
-            {
-                self.surface_configuration.width = size_in_pixels[0];
-                self.surface_configuration.height = size_in_pixels[1];
-                self.surface
-                    .configure(&render_state.device, &self.surface_configuration);
-                self.depth_texture_view = self.generate_depth_texture_view(
-                    render_state,
-                    size_in_pixels[0],
-                    size_in_pixels[1],
-                );
-            }
-
-            let frame = match self.surface.get_current_texture() {
-                Ok(frame) => frame,
-                #[allow(clippy::single_match_else)]
-                Err(e) => match (*self.on_surface_error)(e) {
-                    SurfaceErrorAction::RecreateSurface => {
-                        self.surface
-                            .configure(&render_state.device, &self.surface_configuration);
-                        return Ok(());
-                    }
-                    SurfaceErrorAction::SkipFrame => {
-                        return Ok(());
-                    }
-                },
-            };
-
-            {
-                let renderer = render_state.renderer.read();
-                let frame_view = frame
-                    .texture
-                    .create_view(&wgpu::TextureViewDescriptor::default());
-                let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                        view: &frame_view,
-                        resolve_target: None,
-                        ops: wgpu::Operations {
-                            load: wgpu::LoadOp::Clear(wgpu::Color {
-                                r: clear_color[0] as f64,
-                                g: clear_color[1] as f64,
-                                b: clear_color[2] as f64,
-                                a: clear_color[3] as f64,
-                            }),
-                            store: true,
-                        },
-                    })],
-                    depth_stencil_attachment: self.depth_texture_view.as_ref().map(|view| {
-                        wgpu::RenderPassDepthStencilAttachment {
-                            view,
-                            depth_ops: Some(wgpu::Operations {
-                                load: wgpu::LoadOp::Clear(1.0),
-                                store: false,
-                            }),
-                            stencil_ops: None,
-                        }
-                    }),
-                    label: Some("egui_render"),
-                });
-
-                renderer.render(&mut render_pass, clipped_primitives, &screen_descriptor);
-            }
-
-            Some(frame)
-        };
-
-        {
-            let mut renderer = render_state.renderer.write();
-            for id in &textures_delta.free {
-                renderer.free_texture(id);
-            }
-        }
-
-        // Submit the commands: both the main buffer and user-defined ones.
-        render_state.queue.submit(
-            user_cmd_bufs
-                .into_iter()
-                .chain(std::iter::once(encoder.finish())),
-        );
-
-        if let Some(frame) = frame {
-            frame.present();
-        }
-
-        Ok(())
-    }
-
-    fn destroy(&mut self) {
-        self.render_state = None;
-    }
-}

crates/egui-wgpu/CHANGELOG.md

@@ -1,37 +0,0 @@
-# Changelog for egui-wgpu
-All notable changes to the `egui-wgpu` integration will be noted in this file.
-
-
-## Unreleased
-
-
-## 0.21.0 - 2023-02-08
-* Update to `wgpu` 0.15 ([#2629](https://github.com/emilk/egui/pull/2629))
-* Return `Err` instead of panic if we can't find a device ([#2428](https://github.com/emilk/egui/pull/2428)).
-* `winit::Painter::set_window` is now `async` ([#2434](https://github.com/emilk/egui/pull/2434)).
-* `egui-wgpu` now only depends on `epaint` instead of the entire `egui` ([#2438](https://github.com/emilk/egui/pull/2438)).
-* `winit::Painter` now supports transparent backbuffer ([#2684](https://github.com/emilk/egui/pull/2684)).
-
-
-## 0.20.0 - 2022-12-08 - web support
-* Renamed `RenderPass` to `Renderer`.
-* Renamed `RenderPass::execute` to `RenderPass::render`.
-* Renamed `RenderPass::execute_with_renderpass` to `Renderer::render` (replacing existing `Renderer::render`)
-* Reexported `Renderer`.
-* You can now use `egui-wgpu` on web, using WebGL ([#2107](https://github.com/emilk/egui/pull/2107)).
-* `Renderer` no longer handles pass creation and depth buffer creation ([#2136](https://github.com/emilk/egui/pull/2136))
-* `PrepareCallback` now passes `wgpu::CommandEncoder` ([#2136](https://github.com/emilk/egui/pull/2136))
-* `PrepareCallback` can now returns `wgpu::CommandBuffer` that are bundled into a single `wgpu::Queue::submit` call ([#2230](https://github.com/emilk/egui/pull/2230))
-* Only a single vertex & index buffer is now created and resized when necessary (previously, vertex/index buffers were allocated for every mesh) ([#2148](https://github.com/emilk/egui/pull/2148)).
-* `Renderer::update_texture` no longer creates a new `wgpu::Sampler` with every new texture ([#2198](https://github.com/emilk/egui/pull/2198))
-* `Painter`'s instance/device/adapter/surface creation is now configurable via `WgpuConfiguration` ([#2207](https://github.com/emilk/egui/pull/2207))
-* Fix panic on using a depth buffer ([#2316](https://github.com/emilk/egui/pull/2316))
-
-
-## 0.19.0 - 2022-08-20
-* Enables deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634)).
-* Make `RenderPass` `Send` and `Sync` ([#1883](https://github.com/emilk/egui/pull/1883)).
-
-
-## 0.18.0 - 2022-05-15
-First published version since moving the code into the `egui` repository from <https://github.com/LU15W1R7H/eww>.

crates/egui-wgpu/Cargo.toml

@@ -1,56 +0,0 @@
-[package]
-name = "egui-wgpu"
-version = "0.21.0"
-description = "Bindings for using egui natively using the wgpu library"
-authors = [
-  "Nils Hasenbanck <nils@hasenbanck.de>",
-  "embotech <opensource@embotech.com>",
-  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
-]
-edition = "2021"
-rust-version = "1.65"
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
-categories = ["gui", "game-development"]
-keywords = ["wgpu", "egui", "gui", "gamedev"]
-include = [
-  "../LICENSE-APACHE",
-  "../LICENSE-MIT",
-  "**/*.rs",
-  "**/*.wgsl",
-  "Cargo.toml",
-]
-
-[package.metadata.docs.rs]
-all-features = true
-
-
-[features]
-## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
-puffin = ["dep:puffin"]
-
-## Enable [`winit`](https://docs.rs/winit) integration.
-winit = ["dep:winit"]
-
-
-[dependencies]
-epaint = { version = "0.21.0", path = "../epaint", default-features = false, features = [
-  "bytemuck",
-] }
-
-bytemuck = "1.7"
-tracing = { version = "0.1", default-features = false, features = ["std"] }
-type-map = "0.5.0"
-wgpu = "0.15.0"
-
-#! ### Optional dependencies
-## Enable this when generating docs.
-document-features = { version = "0.2", optional = true }
-
-winit = { version = "0.28", optional = true }
-
-# Native:
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-puffin = { version = "0.14", optional = true }

crates/egui-wgpu/src/egui.wgsl

@@ -1,91 +0,0 @@
-// Vertex shader bindings
-
-struct VertexOutput {
-    @location(0) tex_coord: vec2<f32>,
-    @location(1) color: vec4<f32>, // gamma 0-1
-    @builtin(position) position: vec4<f32>,
-};
-
-struct Locals {
-    screen_size: vec2<f32>,
-    // Uniform buffers need to be at least 16 bytes in WebGL.
-    // See https://github.com/gfx-rs/wgpu/issues/2072
-    _padding: vec2<u32>,
-};
-@group(0) @binding(0) var<uniform> r_locals: Locals;
-
-// 0-1 linear  from  0-1 sRGB gamma
-fn linear_from_gamma_rgb(srgb: vec3<f32>) -> vec3<f32> {
-    let cutoff = srgb < vec3<f32>(0.04045);
-    let lower = srgb / vec3<f32>(12.92);
-    let higher = pow((srgb + vec3<f32>(0.055)) / vec3<f32>(1.055), vec3<f32>(2.4));
-    return select(higher, lower, cutoff);
-}
-
-// 0-1 sRGB gamma  from  0-1 linear
-fn gamma_from_linear_rgb(rgb: vec3<f32>) -> vec3<f32> {
-    let cutoff = rgb < vec3<f32>(0.0031308);
-    let lower = rgb * vec3<f32>(12.92);
-    let higher = vec3<f32>(1.055) * pow(rgb, vec3<f32>(1.0 / 2.4)) - vec3<f32>(0.055);
-    return select(higher, lower, cutoff);
-}
-
-// 0-1 sRGBA gamma  from  0-1 linear
-fn gamma_from_linear_rgba(linear_rgba: vec4<f32>) -> vec4<f32> {
-    return vec4<f32>(gamma_from_linear_rgb(linear_rgba.rgb), linear_rgba.a);
-}
-
-// [u8; 4] SRGB as u32 -> [r, g, b, a] in 0.-1
-fn unpack_color(color: u32) -> vec4<f32> {
-    return vec4<f32>(
-        f32(color & 255u),
-        f32((color >> 8u) & 255u),
-        f32((color >> 16u) & 255u),
-        f32((color >> 24u) & 255u),
-    ) / 255.0;
-}
-
-fn position_from_screen(screen_pos: vec2<f32>) -> vec4<f32> {
-    return vec4<f32>(
-        2.0 * screen_pos.x / r_locals.screen_size.x - 1.0,
-        1.0 - 2.0 * screen_pos.y / r_locals.screen_size.y,
-        0.0,
-        1.0,
-    );
-}
-
-@vertex
-fn vs_main(
-    @location(0) a_pos: vec2<f32>,
-    @location(1) a_tex_coord: vec2<f32>,
-    @location(2) a_color: u32,
-) -> VertexOutput {
-    var out: VertexOutput;
-    out.tex_coord = a_tex_coord;
-    out.color = unpack_color(a_color);
-    out.position = position_from_screen(a_pos);
-    return out;
-}
-
-// Fragment shader bindings
-
-@group(1) @binding(0) var r_tex_color: texture_2d<f32>;
-@group(1) @binding(1) var r_tex_sampler: sampler;
-
-@fragment
-fn fs_main_linear_framebuffer(in: VertexOutput) -> @location(0) vec4<f32> {
-    // We always have an sRGB aware texture at the moment.
-    let tex_linear = textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
-    let tex_gamma = gamma_from_linear_rgba(tex_linear);
-    let out_color_gamma = in.color * tex_gamma;
-    return vec4<f32>(linear_from_gamma_rgb(out_color_gamma.rgb), out_color_gamma.a);
-}
-
-@fragment
-fn fs_main_gamma_framebuffer(in: VertexOutput) -> @location(0) vec4<f32> {
-    // We always have an sRGB aware texture at the moment.
-    let tex_linear = textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
-    let tex_gamma = gamma_from_linear_rgba(tex_linear);
-    let out_color_gamma = in.color * tex_gamma;
-    return out_color_gamma;
-}

crates/egui-wgpu/src/lib.rs

@@ -1,155 +0,0 @@
-//! This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [wgpu](https://crates.io/crates/wgpu).
-//!
-//! ## Feature flags
-#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
-//!
-
-#![allow(unsafe_code)]
-
-pub use wgpu;
-
-/// Low-level painting of [`egui`](https://github.com/emilk/egui) on [`wgpu`].
-pub mod renderer;
-pub use renderer::CallbackFn;
-pub use renderer::Renderer;
-
-/// Module for painting [`egui`](https://github.com/emilk/egui) with [`wgpu`] on [`winit`].
-#[cfg(feature = "winit")]
-pub mod winit;
-
-use std::sync::Arc;
-
-use epaint::mutex::RwLock;
-
-/// Access to the render state for egui.
-#[derive(Clone)]
-pub struct RenderState {
-    pub device: Arc<wgpu::Device>,
-    pub queue: Arc<wgpu::Queue>,
-    pub target_format: wgpu::TextureFormat,
-    pub renderer: Arc<RwLock<Renderer>>,
-}
-
-/// Specifies which action should be taken as consequence of a [`wgpu::SurfaceError`]
-pub enum SurfaceErrorAction {
-    /// Do nothing and skip the current frame.
-    SkipFrame,
-
-    /// Instructs egui to recreate the surface, then skip the current frame.
-    RecreateSurface,
-}
-
-/// Configuration for using wgpu with eframe or the egui-wgpu winit feature.
-#[derive(Clone)]
-pub struct WgpuConfiguration {
-    /// Configuration passed on device request.
-    pub device_descriptor: wgpu::DeviceDescriptor<'static>,
-
-    /// Backends that should be supported (wgpu will pick one of these)
-    pub backends: wgpu::Backends,
-
-    /// Present mode used for the primary surface.
-    pub present_mode: wgpu::PresentMode,
-
-    /// Power preference for the adapter.
-    pub power_preference: wgpu::PowerPreference,
-
-    /// Callback for surface errors.
-    pub on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
-
-    pub depth_format: Option<wgpu::TextureFormat>,
-}
-
-impl Default for WgpuConfiguration {
-    fn default() -> Self {
-        Self {
-            device_descriptor: wgpu::DeviceDescriptor {
-                label: Some("egui wgpu device"),
-                features: wgpu::Features::default(),
-                limits: wgpu::Limits::default(),
-            },
-            backends: wgpu::Backends::PRIMARY | wgpu::Backends::GL,
-            present_mode: wgpu::PresentMode::AutoVsync,
-            power_preference: wgpu::PowerPreference::HighPerformance,
-            depth_format: None,
-
-            on_surface_error: Arc::new(|err| {
-                if err == wgpu::SurfaceError::Outdated {
-                    // This error occurs when the app is minimized on Windows.
-                    // Silently return here to prevent spamming the console with:
-                    // "The underlying surface has changed, and therefore the swap chain must be updated"
-                } else {
-                    tracing::warn!("Dropped frame with error: {err}");
-                }
-                SurfaceErrorAction::SkipFrame
-            }),
-        }
-    }
-}
-
-/// Find the framebuffer format that egui prefers
-pub fn preferred_framebuffer_format(formats: &[wgpu::TextureFormat]) -> wgpu::TextureFormat {
-    for &format in formats {
-        if matches!(
-            format,
-            wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Bgra8Unorm
-        ) {
-            return format;
-        }
-    }
-    formats[0] // take the first
-}
-// maybe use this-error?
-#[derive(Debug)]
-pub enum WgpuError {
-    DeviceError(wgpu::RequestDeviceError),
-    SurfaceError(wgpu::CreateSurfaceError),
-}
-
-impl std::fmt::Display for WgpuError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(self, f)
-    }
-}
-
-impl std::error::Error for WgpuError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            WgpuError::DeviceError(e) => e.source(),
-            WgpuError::SurfaceError(e) => e.source(),
-        }
-    }
-}
-
-impl From<wgpu::RequestDeviceError> for WgpuError {
-    fn from(e: wgpu::RequestDeviceError) -> Self {
-        Self::DeviceError(e)
-    }
-}
-
-impl From<wgpu::CreateSurfaceError> for WgpuError {
-    fn from(e: wgpu::CreateSurfaceError) -> Self {
-        Self::SurfaceError(e)
-    }
-}
-// ---------------------------------------------------------------------------
-
-/// Profiling macro for feature "puffin"
-macro_rules! profile_function {
-    ($($arg: tt)*) => {
-        #[cfg(feature = "puffin")]
-        #[cfg(not(target_arch = "wasm32"))]
-        puffin::profile_function!($($arg)*);
-    };
-}
-pub(crate) use profile_function;
-
-/// Profiling macro for feature "puffin"
-macro_rules! profile_scope {
-    ($($arg: tt)*) => {
-        #[cfg(feature = "puffin")]
-        #[cfg(not(target_arch = "wasm32"))]
-        puffin::profile_scope!($($arg)*);
-    };
-}
-pub(crate) use profile_scope;

crates/egui-wgpu/src/renderer.rs

@@ -1,931 +0,0 @@
-#![allow(unsafe_code)]
-
-use std::num::NonZeroU64;
-use std::ops::Range;
-use std::{borrow::Cow, collections::HashMap, num::NonZeroU32};
-
-use type_map::concurrent::TypeMap;
-use wgpu;
-use wgpu::util::DeviceExt as _;
-
-use epaint::{emath::NumExt, PaintCallbackInfo, Primitive, Vertex};
-
-/// A callback function that can be used to compose an [`epaint::PaintCallback`] for custom WGPU
-/// rendering.
-///
-/// The callback is composed of two functions: `prepare` and `paint`:
-/// - `prepare` is called every frame before `paint`, and can use the passed-in
-///   [`wgpu::Device`] and [`wgpu::Buffer`] to allocate or modify GPU resources such as buffers.
-/// - `paint` is called after `prepare` and is given access to the [`wgpu::RenderPass`] so
-///   that it can issue draw commands into the same [`wgpu::RenderPass`] that is used for
-///   all other egui elements.
-///
-/// The final argument of both the `prepare` and `paint` callbacks is a the
-/// [`paint_callback_resources`][crate::renderer::Renderer::paint_callback_resources].
-/// `paint_callback_resources` has the same lifetime as the Egui render pass, so it can be used to
-/// store buffers, pipelines, and other information that needs to be accessed during the render
-/// pass.
-///
-/// # Example
-///
-/// See the [`custom3d_wgpu`](https://github.com/emilk/egui/blob/master/crates/egui_demo_app/src/apps/custom3d_wgpu.rs) demo source for a detailed usage example.
-pub struct CallbackFn {
-    prepare: Box<PrepareCallback>,
-    paint: Box<PaintCallback>,
-}
-
-type PrepareCallback = dyn Fn(
-        &wgpu::Device,
-        &wgpu::Queue,
-        &mut wgpu::CommandEncoder,
-        &mut TypeMap,
-    ) -> Vec<wgpu::CommandBuffer>
-    + Sync
-    + Send;
-
-type PaintCallback =
-    dyn for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap) + Sync + Send;
-
-impl Default for CallbackFn {
-    fn default() -> Self {
-        CallbackFn {
-            prepare: Box::new(|_, _, _, _| Vec::new()),
-            paint: Box::new(|_, _, _| ()),
-        }
-    }
-}
-
-impl CallbackFn {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the prepare callback.
-    ///
-    /// The passed-in `CommandEncoder` is egui's and can be used directly to register
-    /// wgpu commands for simple use cases.
-    /// This allows reusing the same [`wgpu::CommandEncoder`] for all callbacks and egui
-    /// rendering itself.
-    ///
-    /// For more complicated use cases, one can also return a list of arbitrary
-    /// `CommandBuffer`s and have complete control over how they get created and fed.
-    /// In particular, this gives an opportunity to parallelize command registration and
-    /// prevents a faulty callback from poisoning the main wgpu pipeline.
-    ///
-    /// When using eframe, the main egui command buffer, as well as all user-defined
-    /// command buffers returned by this function, are guaranteed to all be submitted
-    /// at once in a single call.
-    pub fn prepare<F>(mut self, prepare: F) -> Self
-    where
-        F: Fn(
-                &wgpu::Device,
-                &wgpu::Queue,
-                &mut wgpu::CommandEncoder,
-                &mut TypeMap,
-            ) -> Vec<wgpu::CommandBuffer>
-            + Sync
-            + Send
-            + 'static,
-    {
-        self.prepare = Box::new(prepare) as _;
-        self
-    }
-
-    /// Set the paint callback
-    pub fn paint<F>(mut self, paint: F) -> Self
-    where
-        F: for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap)
-            + Sync
-            + Send
-            + 'static,
-    {
-        self.paint = Box::new(paint) as _;
-        self
-    }
-}
-
-/// Information about the screen used for rendering.
-pub struct ScreenDescriptor {
-    /// Size of the window in physical pixels.
-    pub size_in_pixels: [u32; 2],
-
-    /// HiDPI scale factor (pixels per point).
-    pub pixels_per_point: f32,
-}
-
-impl ScreenDescriptor {
-    /// size in "logical" points
-    fn screen_size_in_points(&self) -> [f32; 2] {
-        [
-            self.size_in_pixels[0] as f32 / self.pixels_per_point,
-            self.size_in_pixels[1] as f32 / self.pixels_per_point,
-        ]
-    }
-}
-
-/// Uniform buffer used when rendering.
-#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
-#[repr(C)]
-struct UniformBuffer {
-    screen_size_in_points: [f32; 2],
-    // Uniform buffers need to be at least 16 bytes in WebGL.
-    // See https://github.com/gfx-rs/wgpu/issues/2072
-    _padding: [u32; 2],
-}
-
-struct SlicedBuffer {
-    buffer: wgpu::Buffer,
-    slices: Vec<Range<wgpu::BufferAddress>>,
-    capacity: wgpu::BufferAddress,
-}
-
-/// Renderer for a egui based GUI.
-pub struct Renderer {
-    pipeline: wgpu::RenderPipeline,
-
-    index_buffer: SlicedBuffer,
-    vertex_buffer: SlicedBuffer,
-
-    uniform_buffer: wgpu::Buffer,
-    uniform_bind_group: wgpu::BindGroup,
-    texture_bind_group_layout: wgpu::BindGroupLayout,
-
-    /// Map of egui texture IDs to textures and their associated bindgroups (texture view +
-    /// sampler). The texture may be None if the TextureId is just a handle to a user-provided
-    /// sampler.
-    textures: HashMap<epaint::TextureId, (Option<wgpu::Texture>, wgpu::BindGroup)>,
-    next_user_texture_id: u64,
-    samplers: HashMap<epaint::textures::TextureOptions, wgpu::Sampler>,
-
-    /// Storage for use by [`epaint::PaintCallback`]'s that need to store resources such as render
-    /// pipelines that must have the lifetime of the renderpass.
-    pub paint_callback_resources: TypeMap,
-}
-
-impl Renderer {
-    /// Creates a renderer for a egui UI.
-    ///
-    /// `output_color_format` should preferably be [`wgpu::TextureFormat::Rgba8Unorm`] or
-    /// [`wgpu::TextureFormat::Bgra8Unorm`], i.e. in gamma-space.
-    pub fn new(
-        device: &wgpu::Device,
-        output_color_format: wgpu::TextureFormat,
-        output_depth_format: Option<wgpu::TextureFormat>,
-        msaa_samples: u32,
-    ) -> Self {
-        crate::profile_function!();
-
-        let shader = wgpu::ShaderModuleDescriptor {
-            label: Some("egui"),
-            source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("egui.wgsl"))),
-        };
-        let module = device.create_shader_module(shader);
-
-        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("egui_uniform_buffer"),
-            contents: bytemuck::cast_slice(&[UniformBuffer {
-                screen_size_in_points: [0.0, 0.0],
-                _padding: Default::default(),
-            }]),
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-        });
-
-        let uniform_bind_group_layout =
-            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("egui_uniform_bind_group_layout"),
-                entries: &[wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::VERTEX,
-                    ty: wgpu::BindingType::Buffer {
-                        has_dynamic_offset: false,
-                        min_binding_size: NonZeroU64::new(std::mem::size_of::<UniformBuffer>() as _),
-                        ty: wgpu::BufferBindingType::Uniform,
-                    },
-                    count: None,
-                }],
-            });
-
-        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("egui_uniform_bind_group"),
-            layout: &uniform_bind_group_layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
-                    buffer: &uniform_buffer,
-                    offset: 0,
-                    size: None,
-                }),
-            }],
-        });
-
-        let texture_bind_group_layout =
-            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("egui_texture_bind_group_layout"),
-                entries: &[
-                    wgpu::BindGroupLayoutEntry {
-                        binding: 0,
-                        visibility: wgpu::ShaderStages::FRAGMENT,
-                        ty: wgpu::BindingType::Texture {
-                            multisampled: false,
-                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                            view_dimension: wgpu::TextureViewDimension::D2,
-                        },
-                        count: None,
-                    },
-                    wgpu::BindGroupLayoutEntry {
-                        binding: 1,
-                        visibility: wgpu::ShaderStages::FRAGMENT,
-                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                        count: None,
-                    },
-                ],
-            });
-
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("egui_pipeline_layout"),
-            bind_group_layouts: &[&uniform_bind_group_layout, &texture_bind_group_layout],
-            push_constant_ranges: &[],
-        });
-
-        let depth_stencil = output_depth_format.map(|format| wgpu::DepthStencilState {
-            format,
-            depth_write_enabled: false,
-            depth_compare: wgpu::CompareFunction::Always,
-            stencil: wgpu::StencilState::default(),
-            bias: wgpu::DepthBiasState::default(),
-        });
-
-        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("egui_pipeline"),
-            layout: Some(&pipeline_layout),
-            vertex: wgpu::VertexState {
-                entry_point: "vs_main",
-                module: &module,
-                buffers: &[wgpu::VertexBufferLayout {
-                    array_stride: 5 * 4,
-                    step_mode: wgpu::VertexStepMode::Vertex,
-                    // 0: vec2 position
-                    // 1: vec2 texture coordinates
-                    // 2: uint color
-                    attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2, 2 => Uint32],
-                }],
-            },
-            primitive: wgpu::PrimitiveState {
-                topology: wgpu::PrimitiveTopology::TriangleList,
-                unclipped_depth: false,
-                conservative: false,
-                cull_mode: None,
-                front_face: wgpu::FrontFace::default(),
-                polygon_mode: wgpu::PolygonMode::default(),
-                strip_index_format: None,
-            },
-            depth_stencil,
-            multisample: wgpu::MultisampleState {
-                alpha_to_coverage_enabled: false,
-                count: msaa_samples,
-                mask: !0,
-            },
-
-            fragment: Some(wgpu::FragmentState {
-                module: &module,
-                entry_point: if output_color_format.describe().srgb {
-                    tracing::warn!("Detected a linear (sRGBA aware) framebuffer {:?}. egui prefers Rgba8Unorm or Bgra8Unorm", output_color_format);
-                    "fs_main_linear_framebuffer"
-                } else {
-                    "fs_main_gamma_framebuffer" // this is what we prefer
-                },
-                targets: &[Some(wgpu::ColorTargetState {
-                    format: output_color_format,
-                    blend: Some(wgpu::BlendState {
-                        color: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::One,
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                        alpha: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::OneMinusDstAlpha,
-                            dst_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                    }),
-                    write_mask: wgpu::ColorWrites::ALL,
-                })],
-            }),
-            multiview: None,
-        });
-
-        const VERTEX_BUFFER_START_CAPACITY: wgpu::BufferAddress =
-            (std::mem::size_of::<Vertex>() * 1024) as _;
-        const INDEX_BUFFER_START_CAPACITY: wgpu::BufferAddress =
-            (std::mem::size_of::<u32>() * 1024 * 3) as _;
-
-        Self {
-            pipeline,
-            vertex_buffer: SlicedBuffer {
-                buffer: create_vertex_buffer(device, VERTEX_BUFFER_START_CAPACITY),
-                slices: Vec::with_capacity(64),
-                capacity: VERTEX_BUFFER_START_CAPACITY,
-            },
-            index_buffer: SlicedBuffer {
-                buffer: create_index_buffer(device, INDEX_BUFFER_START_CAPACITY),
-                slices: Vec::with_capacity(64),
-                capacity: INDEX_BUFFER_START_CAPACITY,
-            },
-            uniform_buffer,
-            uniform_bind_group,
-            texture_bind_group_layout,
-            textures: HashMap::new(),
-            next_user_texture_id: 0,
-            samplers: HashMap::new(),
-            paint_callback_resources: TypeMap::default(),
-        }
-    }
-
-    /// Executes the egui renderer onto an existing wgpu renderpass.
-    pub fn render<'rp>(
-        &'rp self,
-        render_pass: &mut wgpu::RenderPass<'rp>,
-        paint_jobs: &[epaint::ClippedPrimitive],
-        screen_descriptor: &ScreenDescriptor,
-    ) {
-        crate::profile_function!();
-
-        let pixels_per_point = screen_descriptor.pixels_per_point;
-        let size_in_pixels = screen_descriptor.size_in_pixels;
-
-        // Whether or not we need to reset the render pass because a paint callback has just
-        // run.
-        let mut needs_reset = true;
-
-        let mut index_buffer_slices = self.index_buffer.slices.iter();
-        let mut vertex_buffer_slices = self.vertex_buffer.slices.iter();
-
-        for epaint::ClippedPrimitive {
-            clip_rect,
-            primitive,
-        } in paint_jobs
-        {
-            if needs_reset {
-                render_pass.set_viewport(
-                    0.0,
-                    0.0,
-                    size_in_pixels[0] as f32,
-                    size_in_pixels[1] as f32,
-                    0.0,
-                    1.0,
-                );
-                render_pass.set_pipeline(&self.pipeline);
-                render_pass.set_bind_group(0, &self.uniform_bind_group, &[]);
-                needs_reset = false;
-            }
-
-            {
-                let rect = ScissorRect::new(clip_rect, pixels_per_point, size_in_pixels);
-
-                if rect.width == 0 || rect.height == 0 {
-                    // Skip rendering zero-sized clip areas.
-                    if let Primitive::Mesh(_) = primitive {
-                        // If this is a mesh, we need to advance the index and vertex buffer iterators:
-                        index_buffer_slices.next().unwrap();
-                        vertex_buffer_slices.next().unwrap();
-                    }
-                    continue;
-                }
-
-                render_pass.set_scissor_rect(rect.x, rect.y, rect.width, rect.height);
-            }
-
-            match primitive {
-                Primitive::Mesh(mesh) => {
-                    let index_buffer_slice = index_buffer_slices.next().unwrap();
-                    let vertex_buffer_slice = vertex_buffer_slices.next().unwrap();
-
-                    if let Some((_texture, bind_group)) = self.textures.get(&mesh.texture_id) {
-                        render_pass.set_bind_group(1, bind_group, &[]);
-                        render_pass.set_index_buffer(
-                            self.index_buffer.buffer.slice(index_buffer_slice.clone()),
-                            wgpu::IndexFormat::Uint32,
-                        );
-                        render_pass.set_vertex_buffer(
-                            0,
-                            self.vertex_buffer.buffer.slice(vertex_buffer_slice.clone()),
-                        );
-                        render_pass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
-                    } else {
-                        tracing::warn!("Missing texture: {:?}", mesh.texture_id);
-                    }
-                }
-                Primitive::Callback(callback) => {
-                    let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
-                        c
-                    } else {
-                        // We already warned in the `prepare` callback
-                        continue;
-                    };
-
-                    if callback.rect.is_positive() {
-                        crate::profile_scope!("callback");
-
-                        needs_reset = true;
-
-                        {
-                            // We're setting a default viewport for the render pass as a
-                            // courtesy for the user, so that they don't have to think about
-                            // it in the simple case where they just want to fill the whole
-                            // paint area.
-                            //
-                            // The user still has the possibility of setting their own custom
-                            // viewport during the paint callback, effectively overriding this
-                            // one.
-
-                            let min = (callback.rect.min.to_vec2() * pixels_per_point).round();
-                            let max = (callback.rect.max.to_vec2() * pixels_per_point).round();
-
-                            render_pass.set_viewport(
-                                min.x,
-                                min.y,
-                                max.x - min.x,
-                                max.y - min.y,
-                                0.0,
-                                1.0,
-                            );
-                        }
-
-                        (cbfn.paint)(
-                            PaintCallbackInfo {
-                                viewport: callback.rect,
-                                clip_rect: *clip_rect,
-                                pixels_per_point,
-                                screen_size_px: size_in_pixels,
-                            },
-                            render_pass,
-                            &self.paint_callback_resources,
-                        );
-                    }
-                }
-            }
-        }
-
-        render_pass.set_scissor_rect(0, 0, size_in_pixels[0], size_in_pixels[1]);
-    }
-
-    /// Should be called before `render()`.
-    pub fn update_texture(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        id: epaint::TextureId,
-        image_delta: &epaint::ImageDelta,
-    ) {
-        crate::profile_function!();
-
-        let width = image_delta.image.width() as u32;
-        let height = image_delta.image.height() as u32;
-
-        let size = wgpu::Extent3d {
-            width,
-            height,
-            depth_or_array_layers: 1,
-        };
-
-        let data_color32 = match &image_delta.image {
-            epaint::ImageData::Color(image) => {
-                assert_eq!(
-                    width as usize * height as usize,
-                    image.pixels.len(),
-                    "Mismatch between texture size and texel count"
-                );
-                Cow::Borrowed(&image.pixels)
-            }
-            epaint::ImageData::Font(image) => {
-                assert_eq!(
-                    width as usize * height as usize,
-                    image.pixels.len(),
-                    "Mismatch between texture size and texel count"
-                );
-                Cow::Owned(image.srgba_pixels(None).collect::<Vec<_>>())
-            }
-        };
-        let data_bytes: &[u8] = bytemuck::cast_slice(data_color32.as_slice());
-
-        let queue_write_data_to_texture = |texture, origin| {
-            queue.write_texture(
-                wgpu::ImageCopyTexture {
-                    texture,
-                    mip_level: 0,
-                    origin,
-                    aspect: wgpu::TextureAspect::All,
-                },
-                data_bytes,
-                wgpu::ImageDataLayout {
-                    offset: 0,
-                    bytes_per_row: NonZeroU32::new(4 * width),
-                    rows_per_image: NonZeroU32::new(height),
-                },
-                size,
-            );
-        };
-
-        if let Some(pos) = image_delta.pos {
-            // update the existing texture
-            let (texture, _bind_group) = self
-                .textures
-                .get(&id)
-                .expect("Tried to update a texture that has not been allocated yet.");
-            let origin = wgpu::Origin3d {
-                x: pos[0] as u32,
-                y: pos[1] as u32,
-                z: 0,
-            };
-            queue_write_data_to_texture(
-                texture.as_ref().expect("Tried to update user texture."),
-                origin,
-            );
-        } else {
-            // allocate a new texture
-            // Use same label for all resources associated with this texture id (no point in retyping the type)
-            let label_str = format!("egui_texid_{:?}", id);
-            let label = Some(label_str.as_str());
-            let texture = device.create_texture(&wgpu::TextureDescriptor {
-                label,
-                size,
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format: wgpu::TextureFormat::Rgba8UnormSrgb, // Minspec for wgpu WebGL emulation is WebGL2, so this should always be supported.
-                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-                view_formats: &[wgpu::TextureFormat::Rgba8UnormSrgb],
-            });
-            let sampler = self
-                .samplers
-                .entry(image_delta.options)
-                .or_insert_with(|| create_sampler(image_delta.options, device));
-            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label,
-                layout: &self.texture_bind_group_layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: wgpu::BindingResource::TextureView(
-                            &texture.create_view(&wgpu::TextureViewDescriptor::default()),
-                        ),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 1,
-                        resource: wgpu::BindingResource::Sampler(sampler),
-                    },
-                ],
-            });
-            let origin = wgpu::Origin3d::ZERO;
-            queue_write_data_to_texture(&texture, origin);
-            self.textures.insert(id, (Some(texture), bind_group));
-        };
-    }
-
-    pub fn free_texture(&mut self, id: &epaint::TextureId) {
-        self.textures.remove(id);
-    }
-
-    /// Get the WGPU texture and bind group associated to a texture that has been allocated by egui.
-    ///
-    /// This could be used by custom paint hooks to render images that have been added through with
-    /// [`egui_extras::RetainedImage`](https://docs.rs/egui_extras/latest/egui_extras/image/struct.RetainedImage.html)
-    /// or [`epaint::Context::load_texture`](https://docs.rs/egui/latest/egui/struct.Context.html#method.load_texture).
-    pub fn texture(
-        &self,
-        id: &epaint::TextureId,
-    ) -> Option<&(Option<wgpu::Texture>, wgpu::BindGroup)> {
-        self.textures.get(id)
-    }
-
-    /// Registers a `wgpu::Texture` with a `epaint::TextureId`.
-    ///
-    /// This enables the application to reference the texture inside an image ui element.
-    /// This effectively enables off-screen rendering inside the egui UI. Texture must have
-    /// the texture format `TextureFormat::Rgba8UnormSrgb` and
-    /// Texture usage `TextureUsage::SAMPLED`.
-    pub fn register_native_texture(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::TextureView,
-        texture_filter: wgpu::FilterMode,
-    ) -> epaint::TextureId {
-        self.register_native_texture_with_sampler_options(
-            device,
-            texture,
-            wgpu::SamplerDescriptor {
-                label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
-                mag_filter: texture_filter,
-                min_filter: texture_filter,
-                ..Default::default()
-            },
-        )
-    }
-
-    /// Registers a `wgpu::Texture` with an existing `epaint::TextureId`.
-    ///
-    /// This enables applications to reuse `TextureId`s.
-    pub fn update_egui_texture_from_wgpu_texture(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::TextureView,
-        texture_filter: wgpu::FilterMode,
-        id: epaint::TextureId,
-    ) {
-        self.update_egui_texture_from_wgpu_texture_with_sampler_options(
-            device,
-            texture,
-            wgpu::SamplerDescriptor {
-                label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
-                mag_filter: texture_filter,
-                min_filter: texture_filter,
-                ..Default::default()
-            },
-            id,
-        );
-    }
-
-    /// Registers a `wgpu::Texture` with a `epaint::TextureId` while also accepting custom
-    /// `wgpu::SamplerDescriptor` options.
-    ///
-    /// This allows applications to specify individual minification/magnification filters as well as
-    /// custom mipmap and tiling options.
-    ///
-    /// The `Texture` must have the format `TextureFormat::Rgba8UnormSrgb` and usage
-    /// `TextureUsage::SAMPLED`. Any compare function supplied in the `SamplerDescriptor` will be
-    /// ignored.
-    #[allow(clippy::needless_pass_by_value)] // false positive
-    pub fn register_native_texture_with_sampler_options(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::TextureView,
-        sampler_descriptor: wgpu::SamplerDescriptor<'_>,
-    ) -> epaint::TextureId {
-        crate::profile_function!();
-
-        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            compare: None,
-            ..sampler_descriptor
-        });
-
-        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
-            layout: &self.texture_bind_group_layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(texture),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&sampler),
-                },
-            ],
-        });
-
-        let id = epaint::TextureId::User(self.next_user_texture_id);
-        self.textures.insert(id, (None, bind_group));
-        self.next_user_texture_id += 1;
-
-        id
-    }
-
-    /// Registers a `wgpu::Texture` with an existing `epaint::TextureId` while also accepting custom
-    /// `wgpu::SamplerDescriptor` options.
-    ///
-    /// This allows applications to reuse `TextureId`s created with custom sampler options.
-    #[allow(clippy::needless_pass_by_value)] // false positive
-    pub fn update_egui_texture_from_wgpu_texture_with_sampler_options(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::TextureView,
-        sampler_descriptor: wgpu::SamplerDescriptor<'_>,
-        id: epaint::TextureId,
-    ) {
-        crate::profile_function!();
-
-        let (_user_texture, user_texture_binding) = self
-            .textures
-            .get_mut(&id)
-            .expect("Tried to update a texture that has not been allocated yet.");
-
-        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            compare: None,
-            ..sampler_descriptor
-        });
-
-        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
-            layout: &self.texture_bind_group_layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(texture),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&sampler),
-                },
-            ],
-        });
-
-        *user_texture_binding = bind_group;
-    }
-
-    /// Uploads the uniform, vertex and index data used by the renderer.
-    /// Should be called before `render()`.
-    ///
-    /// Returns all user-defined command buffers gathered from prepare callbacks.
-    pub fn update_buffers(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        paint_jobs: &[epaint::ClippedPrimitive],
-        screen_descriptor: &ScreenDescriptor,
-    ) -> Vec<wgpu::CommandBuffer> {
-        crate::profile_function!();
-
-        let screen_size_in_points = screen_descriptor.screen_size_in_points();
-
-        {
-            crate::profile_scope!("uniforms");
-            // Update uniform buffer
-            queue.write_buffer(
-                &self.uniform_buffer,
-                0,
-                bytemuck::cast_slice(&[UniformBuffer {
-                    screen_size_in_points,
-                    _padding: Default::default(),
-                }]),
-            );
-        }
-
-        // Determine how many vertices & indices need to be rendered.
-        let (vertex_count, index_count) = {
-            crate::profile_scope!("count_vertices_indices");
-            paint_jobs.iter().fold((0, 0), |acc, clipped_primitive| {
-                match &clipped_primitive.primitive {
-                    Primitive::Mesh(mesh) => {
-                        (acc.0 + mesh.vertices.len(), acc.1 + mesh.indices.len())
-                    }
-                    Primitive::Callback(_) => acc,
-                }
-            })
-        };
-
-        {
-            // Resize index buffer if needed:
-            self.index_buffer.slices.clear();
-            let required_size = (std::mem::size_of::<u32>() * index_count) as u64;
-            if self.index_buffer.capacity < required_size {
-                self.index_buffer.capacity =
-                    (self.index_buffer.capacity * 2).at_least(required_size);
-                self.index_buffer.buffer = create_index_buffer(device, self.index_buffer.capacity);
-            }
-        }
-
-        {
-            // Resize vertex buffer if needed:
-            self.vertex_buffer.slices.clear();
-            let required_size = (std::mem::size_of::<Vertex>() * vertex_count) as u64;
-            if self.vertex_buffer.capacity < required_size {
-                self.vertex_buffer.capacity =
-                    (self.vertex_buffer.capacity * 2).at_least(required_size);
-                self.vertex_buffer.buffer =
-                    create_vertex_buffer(device, self.vertex_buffer.capacity);
-            }
-        }
-
-        // Upload index & vertex data and call user callbacks
-        let mut user_cmd_bufs = Vec::new(); // collect user command buffers
-
-        crate::profile_scope!("primitives");
-        for epaint::ClippedPrimitive { primitive, .. } in paint_jobs.iter() {
-            match primitive {
-                Primitive::Mesh(mesh) => {
-                    {
-                        let index_offset = self.index_buffer.slices.last().unwrap_or(&(0..0)).end;
-                        let data = bytemuck::cast_slice(&mesh.indices);
-                        queue.write_buffer(&self.index_buffer.buffer, index_offset, data);
-                        self.index_buffer
-                            .slices
-                            .push(index_offset..(data.len() as wgpu::BufferAddress + index_offset));
-                    }
-                    {
-                        let vertex_offset = self.vertex_buffer.slices.last().unwrap_or(&(0..0)).end;
-                        let data = bytemuck::cast_slice(&mesh.vertices);
-                        queue.write_buffer(&self.vertex_buffer.buffer, vertex_offset, data);
-                        self.vertex_buffer.slices.push(
-                            vertex_offset..(data.len() as wgpu::BufferAddress + vertex_offset),
-                        );
-                    }
-                }
-                Primitive::Callback(callback) => {
-                    let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
-                        c
-                    } else {
-                        tracing::warn!("Unknown paint callback: expected `egui_wgpu::CallbackFn`");
-                        continue;
-                    };
-
-                    crate::profile_scope!("callback");
-                    user_cmd_bufs.extend((cbfn.prepare)(
-                        device,
-                        queue,
-                        encoder,
-                        &mut self.paint_callback_resources,
-                    ));
-                }
-            }
-        }
-
-        user_cmd_bufs
-    }
-}
-
-fn create_sampler(
-    options: epaint::textures::TextureOptions,
-    device: &wgpu::Device,
-) -> wgpu::Sampler {
-    let mag_filter = match options.magnification {
-        epaint::textures::TextureFilter::Nearest => wgpu::FilterMode::Nearest,
-        epaint::textures::TextureFilter::Linear => wgpu::FilterMode::Linear,
-    };
-    let min_filter = match options.minification {
-        epaint::textures::TextureFilter::Nearest => wgpu::FilterMode::Nearest,
-        epaint::textures::TextureFilter::Linear => wgpu::FilterMode::Linear,
-    };
-    device.create_sampler(&wgpu::SamplerDescriptor {
-        label: Some(&format!(
-            "egui sampler (mag: {:?}, min {:?})",
-            mag_filter, min_filter
-        )),
-        mag_filter,
-        min_filter,
-        ..Default::default()
-    })
-}
-
-fn create_vertex_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
-    crate::profile_function!();
-    device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("egui_vertex_buffer"),
-        usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
-        size,
-        mapped_at_creation: false,
-    })
-}
-
-fn create_index_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
-    crate::profile_function!();
-    device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("egui_index_buffer"),
-        usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
-        size,
-        mapped_at_creation: false,
-    })
-}
-
-/// A Rect in physical pixel space, used for setting cliipping rectangles.
-struct ScissorRect {
-    x: u32,
-    y: u32,
-    width: u32,
-    height: u32,
-}
-
-impl ScissorRect {
-    fn new(clip_rect: &epaint::Rect, pixels_per_point: f32, target_size: [u32; 2]) -> Self {
-        // Transform clip rect to physical pixels:
-        let clip_min_x = pixels_per_point * clip_rect.min.x;
-        let clip_min_y = pixels_per_point * clip_rect.min.y;
-        let clip_max_x = pixels_per_point * clip_rect.max.x;
-        let clip_max_y = pixels_per_point * clip_rect.max.y;
-
-        // Round to integer:
-        let clip_min_x = clip_min_x.round() as u32;
-        let clip_min_y = clip_min_y.round() as u32;
-        let clip_max_x = clip_max_x.round() as u32;
-        let clip_max_y = clip_max_y.round() as u32;
-
-        // Clamp:
-        let clip_min_x = clip_min_x.clamp(0, target_size[0]);
-        let clip_min_y = clip_min_y.clamp(0, target_size[1]);
-        let clip_max_x = clip_max_x.clamp(clip_min_x, target_size[0]);
-        let clip_max_y = clip_max_y.clamp(clip_min_y, target_size[1]);
-
-        Self {
-            x: clip_min_x,
-            y: clip_min_y,
-            width: clip_max_x - clip_min_x,
-            height: clip_max_y - clip_min_y,
-        }
-    }
-}
-
-#[test]
-fn renderer_impl_send_sync() {
-    fn assert_send_sync<T: Send + Sync>() {}
-    assert_send_sync::<Renderer>();
-}

crates/egui-wgpu/src/winit.rs

@@ -1,418 +0,0 @@
-use std::sync::Arc;
-
-use epaint::mutex::RwLock;
-
-use tracing::error;
-
-use crate::{renderer, RenderState, Renderer, SurfaceErrorAction, WgpuConfiguration};
-
-struct SurfaceState {
-    surface: wgpu::Surface,
-    alpha_mode: wgpu::CompositeAlphaMode,
-    width: u32,
-    height: u32,
-}
-
-/// Everything you need to paint egui with [`wgpu`] on [`winit`].
-///
-/// Alternatively you can use [`crate::renderer`] directly.
-pub struct Painter {
-    configuration: WgpuConfiguration,
-    msaa_samples: u32,
-    support_transparent_backbuffer: bool,
-    depth_format: Option<wgpu::TextureFormat>,
-    depth_texture_view: Option<wgpu::TextureView>,
-
-    instance: wgpu::Instance,
-    adapter: Option<wgpu::Adapter>,
-    render_state: Option<RenderState>,
-    surface_state: Option<SurfaceState>,
-}
-
-impl Painter {
-    /// Manages [`wgpu`] state, including surface state, required to render egui.
-    ///
-    /// Only the [`wgpu::Instance`] is initialized here. Device selection and the initialization
-    /// of render + surface state is deferred until the painter is given its first window target
-    /// via [`set_window()`](Self::set_window). (Ensuring that a device that's compatible with the
-    /// native window is chosen)
-    ///
-    /// Before calling [`paint_and_update_textures()`](Self::paint_and_update_textures) a
-    /// [`wgpu::Surface`] must be initialized (and corresponding render state) by calling
-    /// [`set_window()`](Self::set_window) once you have
-    /// a [`winit::window::Window`] with a valid `.raw_window_handle()`
-    /// associated.
-    pub fn new(
-        configuration: WgpuConfiguration,
-        msaa_samples: u32,
-        depth_bits: u8,
-        support_transparent_backbuffer: bool,
-    ) -> Self {
-        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-            backends: configuration.backends,
-            dx12_shader_compiler: Default::default(), //
-        });
-
-        Self {
-            configuration,
-            msaa_samples,
-            support_transparent_backbuffer,
-            depth_format: (depth_bits > 0).then_some(wgpu::TextureFormat::Depth32Float),
-            depth_texture_view: None,
-
-            instance,
-            adapter: None,
-            render_state: None,
-            surface_state: None,
-        }
-    }
-
-    /// Get the [`RenderState`].
-    ///
-    /// Will return [`None`] if the render state has not been initialized yet.
-    pub fn render_state(&self) -> Option<RenderState> {
-        self.render_state.clone()
-    }
-
-    async fn init_render_state(
-        &self,
-        adapter: &wgpu::Adapter,
-        target_format: wgpu::TextureFormat,
-    ) -> Result<RenderState, wgpu::RequestDeviceError> {
-        adapter
-            .request_device(&self.configuration.device_descriptor, None)
-            .await
-            .map(|(device, queue)| {
-                let renderer =
-                    Renderer::new(&device, target_format, self.depth_format, self.msaa_samples);
-                RenderState {
-                    device: Arc::new(device),
-                    queue: Arc::new(queue),
-                    target_format,
-                    renderer: Arc::new(RwLock::new(renderer)),
-                }
-            })
-    }
-
-    // We want to defer the initialization of our render state until we have a surface
-    // so we can take its format into account.
-    //
-    // After we've initialized our render state once though we expect all future surfaces
-    // will have the same format and so this render state will remain valid.
-    async fn ensure_render_state_for_surface(
-        &mut self,
-        surface: &wgpu::Surface,
-    ) -> Result<(), wgpu::RequestDeviceError> {
-        if self.adapter.is_none() {
-            self.adapter = self
-                .instance
-                .request_adapter(&wgpu::RequestAdapterOptions {
-                    power_preference: self.configuration.power_preference,
-                    compatible_surface: Some(surface),
-                    force_fallback_adapter: false,
-                })
-                .await;
-        }
-        if self.render_state.is_none() {
-            match &self.adapter {
-                Some(adapter) => {
-                    let swapchain_format = crate::preferred_framebuffer_format(
-                        &surface.get_capabilities(adapter).formats,
-                    );
-                    let rs = self.init_render_state(adapter, swapchain_format).await?;
-                    self.render_state = Some(rs);
-                }
-                None => return Err(wgpu::RequestDeviceError {}),
-            }
-        }
-        Ok(())
-    }
-
-    fn configure_surface(
-        surface_state: &SurfaceState,
-        render_state: &RenderState,
-        present_mode: wgpu::PresentMode,
-    ) {
-        surface_state.surface.configure(
-            &render_state.device,
-            &wgpu::SurfaceConfiguration {
-                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-                format: render_state.target_format,
-                width: surface_state.width,
-                height: surface_state.height,
-                present_mode,
-                alpha_mode: surface_state.alpha_mode,
-                view_formats: vec![render_state.target_format],
-            },
-        );
-    }
-
-    /// Updates (or clears) the [`winit::window::Window`] associated with the [`Painter`]
-    ///
-    /// This creates a [`wgpu::Surface`] for the given Window (as well as initializing render
-    /// state if needed) that is used for egui rendering.
-    ///
-    /// This must be called before trying to render via
-    /// [`paint_and_update_textures`](Self::paint_and_update_textures)
-    ///
-    /// # Portability
-    ///
-    /// _In particular it's important to note that on Android a it's only possible to create
-    /// a window surface between `Resumed` and `Paused` lifecycle events, and Winit will panic on
-    /// attempts to query the raw window handle while paused._
-    ///
-    /// On Android [`set_window`](Self::set_window) should be called with `Some(window)` for each
-    /// `Resumed` event and `None` for each `Paused` event. Currently, on all other platforms
-    /// [`set_window`](Self::set_window) may be called with `Some(window)` as soon as you have a
-    /// valid [`winit::window::Window`].
-    ///
-    /// # Safety
-    ///
-    /// The raw Window handle associated with the given `window` must be a valid object to create a
-    /// surface upon and must remain valid for the lifetime of the created surface. (The surface may
-    /// be cleared by passing `None`).
-    ///
-    /// # Errors
-    /// If the provided wgpu configuration does not match an available device.
-    pub async unsafe fn set_window(
-        &mut self,
-        window: Option<&winit::window::Window>,
-    ) -> Result<(), crate::WgpuError> {
-        match window {
-            Some(window) => {
-                let surface = self.instance.create_surface(&window)?;
-
-                self.ensure_render_state_for_surface(&surface).await?;
-
-                let alpha_mode = if self.support_transparent_backbuffer {
-                    let supported_alpha_modes = surface
-                        .get_capabilities(self.adapter.as_ref().unwrap())
-                        .alpha_modes;
-
-                    // Prefer pre multiplied over post multiplied!
-                    if supported_alpha_modes.contains(&wgpu::CompositeAlphaMode::PreMultiplied) {
-                        wgpu::CompositeAlphaMode::PreMultiplied
-                    } else if supported_alpha_modes
-                        .contains(&wgpu::CompositeAlphaMode::PostMultiplied)
-                    {
-                        wgpu::CompositeAlphaMode::PostMultiplied
-                    } else {
-                        tracing::warn!("Transparent window was requested, but the active wgpu surface does not support a `CompositeAlphaMode` with transparency.");
-                        wgpu::CompositeAlphaMode::Auto
-                    }
-                } else {
-                    wgpu::CompositeAlphaMode::Auto
-                };
-
-                let size = window.inner_size();
-                self.surface_state = Some(SurfaceState {
-                    surface,
-                    width: size.width,
-                    height: size.height,
-                    alpha_mode,
-                });
-                self.resize_and_generate_depth_texture_view(size.width, size.height);
-            }
-            None => {
-                self.surface_state = None;
-            }
-        }
-        Ok(())
-    }
-
-    /// Returns the maximum texture dimension supported if known
-    ///
-    /// This API will only return a known dimension after `set_window()` has been called
-    /// at least once, since the underlying device and render state are initialized lazily
-    /// once we have a window (that may determine the choice of adapter/device).
-    pub fn max_texture_side(&self) -> Option<usize> {
-        self.render_state
-            .as_ref()
-            .map(|rs| rs.device.limits().max_texture_dimension_2d as usize)
-    }
-
-    fn resize_and_generate_depth_texture_view(
-        &mut self,
-        width_in_pixels: u32,
-        height_in_pixels: u32,
-    ) {
-        let render_state = self.render_state.as_ref().unwrap();
-        let surface_state = self.surface_state.as_mut().unwrap();
-
-        surface_state.width = width_in_pixels;
-        surface_state.height = height_in_pixels;
-
-        Self::configure_surface(surface_state, render_state, self.configuration.present_mode);
-
-        self.depth_texture_view = self.depth_format.map(|depth_format| {
-            render_state
-                .device
-                .create_texture(&wgpu::TextureDescriptor {
-                    label: Some("egui_depth_texture"),
-                    size: wgpu::Extent3d {
-                        width: width_in_pixels,
-                        height: height_in_pixels,
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: depth_format,
-                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                        | wgpu::TextureUsages::TEXTURE_BINDING,
-                    view_formats: &[depth_format],
-                })
-                .create_view(&wgpu::TextureViewDescriptor::default())
-        });
-    }
-
-    pub fn on_window_resized(&mut self, width_in_pixels: u32, height_in_pixels: u32) {
-        if self.surface_state.is_some() {
-            self.resize_and_generate_depth_texture_view(width_in_pixels, height_in_pixels);
-        } else {
-            error!("Ignoring window resize notification with no surface created via Painter::set_window()");
-        }
-    }
-
-    pub fn paint_and_update_textures(
-        &mut self,
-        pixels_per_point: f32,
-        clear_color: [f32; 4],
-        clipped_primitives: &[epaint::ClippedPrimitive],
-        textures_delta: &epaint::textures::TexturesDelta,
-    ) {
-        crate::profile_function!();
-
-        let render_state = match self.render_state.as_mut() {
-            Some(rs) => rs,
-            None => return,
-        };
-        let surface_state = match self.surface_state.as_ref() {
-            Some(rs) => rs,
-            None => return,
-        };
-
-        let output_frame = {
-            crate::profile_scope!("get_current_texture");
-            // This is what vsync-waiting happens, at least on Mac.
-            surface_state.surface.get_current_texture()
-        };
-
-        let output_frame = match output_frame {
-            Ok(frame) => frame,
-            #[allow(clippy::single_match_else)]
-            Err(e) => match (*self.configuration.on_surface_error)(e) {
-                SurfaceErrorAction::RecreateSurface => {
-                    Self::configure_surface(
-                        surface_state,
-                        render_state,
-                        self.configuration.present_mode,
-                    );
-                    return;
-                }
-                SurfaceErrorAction::SkipFrame => {
-                    return;
-                }
-            },
-        };
-
-        let mut encoder =
-            render_state
-                .device
-                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                    label: Some("encoder"),
-                });
-
-        // Upload all resources for the GPU.
-        let screen_descriptor = renderer::ScreenDescriptor {
-            size_in_pixels: [surface_state.width, surface_state.height],
-            pixels_per_point,
-        };
-
-        let user_cmd_bufs = {
-            let mut renderer = render_state.renderer.write();
-            for (id, image_delta) in &textures_delta.set {
-                renderer.update_texture(
-                    &render_state.device,
-                    &render_state.queue,
-                    *id,
-                    image_delta,
-                );
-            }
-
-            renderer.update_buffers(
-                &render_state.device,
-                &render_state.queue,
-                &mut encoder,
-                clipped_primitives,
-                &screen_descriptor,
-            )
-        };
-
-        {
-            let renderer = render_state.renderer.read();
-            let frame_view = output_frame
-                .texture
-                .create_view(&wgpu::TextureViewDescriptor::default());
-            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &frame_view,
-                    resolve_target: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color {
-                            r: clear_color[0] as f64,
-                            g: clear_color[1] as f64,
-                            b: clear_color[2] as f64,
-                            a: clear_color[3] as f64,
-                        }),
-                        store: true,
-                    },
-                })],
-                depth_stencil_attachment: self.depth_texture_view.as_ref().map(|view| {
-                    wgpu::RenderPassDepthStencilAttachment {
-                        view,
-                        depth_ops: Some(wgpu::Operations {
-                            load: wgpu::LoadOp::Clear(1.0),
-                            store: true,
-                        }),
-                        stencil_ops: None,
-                    }
-                }),
-                label: Some("egui_render"),
-            });
-
-            renderer.render(&mut render_pass, clipped_primitives, &screen_descriptor);
-        }
-
-        {
-            let mut renderer = render_state.renderer.write();
-            for id in &textures_delta.free {
-                renderer.free_texture(id);
-            }
-        }
-
-        let encoded = {
-            crate::profile_scope!("CommandEncoder::finish");
-            encoder.finish()
-        };
-
-        // Submit the commands: both the main buffer and user-defined ones.
-        {
-            crate::profile_scope!("Queue::submit");
-            render_state
-                .queue
-                .submit(user_cmd_bufs.into_iter().chain(std::iter::once(encoded)));
-        };
-
-        // Redraw egui
-        {
-            crate::profile_scope!("present");
-            output_frame.present();
-        }
-    }
-
-    #[allow(clippy::unused_self)]
-    pub fn destroy(&mut self) {
-        // TODO(emilk): something here?
-    }
-}

crates/egui-winit/src/window_settings.rs

@@ -1,144 +0,0 @@
-/// Can be used to store native window settings (position and size).
-#[derive(Clone, Copy, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct WindowSettings {
-    /// Position of window in physical pixels. This is either
-    /// the inner or outer position depending on the platform.
-    /// See [`winit::window::WindowBuilder::with_position`] for details.
-    position: Option<egui::Pos2>,
-
-    fullscreen: bool,
-
-    /// Inner size of window in logical pixels
-    inner_size_points: Option<egui::Vec2>,
-}
-
-impl WindowSettings {
-    pub fn from_display(window: &winit::window::Window) -> Self {
-        let inner_size_points = window.inner_size().to_logical::<f32>(window.scale_factor());
-        let position = if cfg!(macos) {
-            // MacOS uses inner position when positioning windows.
-            window
-                .inner_position()
-                .ok()
-                .map(|p| egui::pos2(p.x as f32, p.y as f32))
-        } else {
-            // Other platforms use the outer position.
-            window
-                .outer_position()
-                .ok()
-                .map(|p| egui::pos2(p.x as f32, p.y as f32))
-        };
-
-        Self {
-            position,
-
-            fullscreen: window.fullscreen().is_some(),
-
-            inner_size_points: Some(egui::vec2(
-                inner_size_points.width,
-                inner_size_points.height,
-            )),
-        }
-    }
-
-    pub fn inner_size_points(&self) -> Option<egui::Vec2> {
-        self.inner_size_points
-    }
-
-    pub fn initialize_window(
-        &self,
-        mut window: winit::window::WindowBuilder,
-    ) -> winit::window::WindowBuilder {
-        // If the app last ran on two monitors and only one is now connected, then
-        // the given position is invalid.
-        // If this happens on Mac, the window is clamped into valid area.
-        // If this happens on Windows, the clamping behavior is managed by the function
-        // clamp_window_to_sane_position.
-        if let Some(pos) = self.position {
-            window = window.with_position(winit::dpi::PhysicalPosition {
-                x: pos.x as f64,
-                y: pos.y as f64,
-            });
-        }
-
-        if let Some(inner_size_points) = self.inner_size_points {
-            window
-                .with_inner_size(winit::dpi::LogicalSize {
-                    width: inner_size_points.x as f64,
-                    height: inner_size_points.y as f64,
-                })
-                .with_fullscreen(
-                    self.fullscreen
-                        .then_some(winit::window::Fullscreen::Borderless(None)),
-                )
-        } else {
-            window
-        }
-    }
-
-    pub fn clamp_to_sane_values(&mut self, max_size: egui::Vec2) {
-        use egui::NumExt as _;
-
-        if let Some(size) = &mut self.inner_size_points {
-            // Prevent ridiculously small windows
-            let min_size = egui::Vec2::splat(64.0);
-            *size = size.at_least(min_size);
-            *size = size.at_most(max_size);
-        }
-    }
-
-    pub fn clamp_window_to_sane_position<E>(
-        &mut self,
-        event_loop: &winit::event_loop::EventLoopWindowTarget<E>,
-    ) {
-        if let (Some(position), Some(inner_size_points)) =
-            (&mut self.position, &self.inner_size_points)
-        {
-            let monitors = event_loop.available_monitors();
-            // default to primary monitor, in case the correct monitor was disconnected.
-            let mut active_monitor = if let Some(active_monitor) = event_loop
-                .primary_monitor()
-                .or_else(|| event_loop.available_monitors().next())
-            {
-                active_monitor
-            } else {
-                return; // no monitors 🤷
-            };
-            for monitor in monitors {
-                let monitor_x_range = (monitor.position().x - inner_size_points.x as i32)
-                    ..(monitor.position().x + monitor.size().width as i32);
-                let monitor_y_range = (monitor.position().y - inner_size_points.y as i32)
-                    ..(monitor.position().y + monitor.size().height as i32);
-
-                if monitor_x_range.contains(&(position.x as i32))
-                    && monitor_y_range.contains(&(position.y as i32))
-                {
-                    active_monitor = monitor;
-                }
-            }
-
-            let mut inner_size_pixels = *inner_size_points * (active_monitor.scale_factor() as f32);
-            // Add size of title bar. This is 32 px by default in Win 10/11.
-            if cfg!(target_os = "windows") {
-                inner_size_pixels +=
-                    egui::Vec2::new(0.0, 32.0 * active_monitor.scale_factor() as f32);
-            }
-            let monitor_position = egui::Pos2::new(
-                active_monitor.position().x as f32,
-                active_monitor.position().y as f32,
-            );
-            let monitor_size = egui::Vec2::new(
-                active_monitor.size().width as f32,
-                active_monitor.size().height as f32,
-            );
-
-            // Window size cannot be negative or the subsequent `clamp` will panic.
-            let window_size = (monitor_size - inner_size_pixels).max(egui::Vec2::ZERO);
-            // To get the maximum position, we get the rightmost corner of the display, then
-            // subtract the size of the window to get the bottom right most value window.position
-            // can have.
-            *position = position.clamp(monitor_position, monitor_position + window_size);
-        }
-    }
-}

crates/egui/src/gui_zoom.rs

@@ -1,117 +0,0 @@
-//! Helpers for zooming the whole GUI of an app (changing [`Context::pixels_per_point`].
-//!
-use crate::*;
-
-/// The suggested keyboard shortcuts for global gui zooming.
-pub mod kb_shortcuts {
-    use super::*;
-
-    pub const ZOOM_IN: KeyboardShortcut =
-        KeyboardShortcut::new(Modifiers::COMMAND, Key::PlusEquals);
-    pub const ZOOM_OUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::Minus);
-    pub const ZOOM_RESET: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::Num0);
-}
-
-/// Let the user scale the GUI (change `Context::pixels_per_point`) by pressing
-/// Cmd+Plus, Cmd+Minus or Cmd+0, just like in a browser.
-///
-/// When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe), you want to call this as:
-/// ```ignore
-/// // On web, the browser controls the gui zoom.
-/// if !frame.is_web() {
-///     egui::gui_zoom::zoom_with_keyboard_shortcuts(
-///         ctx,
-///         frame.info().native_pixels_per_point,
-///     );
-/// }
-/// ```
-pub fn zoom_with_keyboard_shortcuts(ctx: &Context, native_pixels_per_point: Option<f32>) {
-    if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_RESET)) {
-        if let Some(native_pixels_per_point) = native_pixels_per_point {
-            ctx.set_pixels_per_point(native_pixels_per_point);
-        }
-    } else {
-        if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_IN)) {
-            zoom_in(ctx);
-        }
-        if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_OUT)) {
-            zoom_out(ctx);
-        }
-    }
-}
-
-const MIN_PIXELS_PER_POINT: f32 = 0.2;
-const MAX_PIXELS_PER_POINT: f32 = 4.0;
-
-/// Make everything larger.
-pub fn zoom_in(ctx: &Context) {
-    let mut pixels_per_point = ctx.pixels_per_point();
-    pixels_per_point += 0.1;
-    pixels_per_point = pixels_per_point.clamp(MIN_PIXELS_PER_POINT, MAX_PIXELS_PER_POINT);
-    pixels_per_point = (pixels_per_point * 10.).round() / 10.;
-    ctx.set_pixels_per_point(pixels_per_point);
-}
-
-/// Make everything smaller.
-pub fn zoom_out(ctx: &Context) {
-    let mut pixels_per_point = ctx.pixels_per_point();
-    pixels_per_point -= 0.1;
-    pixels_per_point = pixels_per_point.clamp(MIN_PIXELS_PER_POINT, MAX_PIXELS_PER_POINT);
-    pixels_per_point = (pixels_per_point * 10.).round() / 10.;
-    ctx.set_pixels_per_point(pixels_per_point);
-}
-
-/// Show buttons for zooming the ui.
-///
-/// This is meant to be called from within a menu (See [`Ui::menu_button`]).
-///
-/// When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe), you want to call this as:
-/// ```ignore
-/// // On web, the browser controls the gui zoom.
-/// if !frame.is_web() {
-///     ui.menu_button("View", |ui| {
-///         egui::gui_zoom::zoom_menu_buttons(
-///             ui,
-///             frame.info().native_pixels_per_point,
-///         );
-///     });
-/// }
-/// ```
-pub fn zoom_menu_buttons(ui: &mut Ui, native_pixels_per_point: Option<f32>) {
-    if ui
-        .add_enabled(
-            ui.ctx().pixels_per_point() < MAX_PIXELS_PER_POINT,
-            Button::new("Zoom In").shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_IN)),
-        )
-        .clicked()
-    {
-        zoom_in(ui.ctx());
-        ui.close_menu();
-    }
-
-    if ui
-        .add_enabled(
-            ui.ctx().pixels_per_point() > MIN_PIXELS_PER_POINT,
-            Button::new("Zoom Out")
-                .shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_OUT)),
-        )
-        .clicked()
-    {
-        zoom_out(ui.ctx());
-        ui.close_menu();
-    }
-
-    if let Some(native_pixels_per_point) = native_pixels_per_point {
-        if ui
-            .add_enabled(
-                ui.ctx().pixels_per_point() != native_pixels_per_point,
-                Button::new("Reset Zoom")
-                    .shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_RESET)),
-            )
-            .clicked()
-        {
-            ui.ctx().set_pixels_per_point(native_pixels_per_point);
-            ui.close_menu();
-        }
-    }
-}

crates/egui/src/os.rs

@@ -1,76 +0,0 @@
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum OperatingSystem {
-    /// Unknown OS - could be wasm
-    Unknown,
-
-    /// Android OS.
-    Android,
-
-    /// Apple iPhone OS.
-    IOS,
-
-    /// Linux or Unix other than Android.
-    Nix,
-
-    /// MacOS.
-    Mac,
-
-    /// Windows.
-    Windows,
-}
-
-impl Default for OperatingSystem {
-    fn default() -> Self {
-        Self::from_target_os()
-    }
-}
-
-impl OperatingSystem {
-    pub const fn from_target_os() -> Self {
-        if cfg!(target_arch = "wasm32") {
-            Self::Unknown
-        } else if cfg!(target_os = "android") {
-            Self::Android
-        } else if cfg!(target_os = "ios") {
-            Self::IOS
-        } else if cfg!(target_os = "macos") {
-            Self::Mac
-        } else if cfg!(target_os = "windows") {
-            Self::Android
-        } else if cfg!(target_os = "linux")
-            || cfg!(target_os = "dragonfly")
-            || cfg!(target_os = "freebsd")
-            || cfg!(target_os = "netbsd")
-            || cfg!(target_os = "openbsd")
-        {
-            Self::Nix
-        } else {
-            Self::Unknown
-        }
-    }
-
-    /// Helper: try to guess from the user-agent of a browser.
-    pub fn from_user_agent(user_agent: &str) -> Self {
-        if user_agent.contains("Android") {
-            Self::Android
-        } else if user_agent.contains("like Mac") {
-            Self::IOS
-        } else if user_agent.contains("Win") {
-            Self::Windows
-        } else if user_agent.contains("Mac") {
-            Self::Mac
-        } else if user_agent.contains("Linux")
-            || user_agent.contains("X11")
-            || user_agent.contains("Unix")
-        {
-            Self::Nix
-        } else {
-            #[cfg(feature = "tracing")]
-            tracing::warn!(
-                "egui: Failed to guess operating system from User-Agent {:?}. Please file an issue at https://github.com/emilk/egui/issues",
-                user_agent);
-
-            Self::Unknown
-        }
-    }
-}

crates/egui/src/widgets/drag_value.rs

@@ -1,662 +0,0 @@
-#![allow(clippy::needless_pass_by_value)] // False positives with `impl ToString`
-
-use std::{cmp::Ordering, ops::RangeInclusive};
-
-use crate::*;
-
-// ----------------------------------------------------------------------------
-
-/// Same state for all [`DragValue`]s.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct MonoState {
-    last_dragged_id: Option<Id>,
-    last_dragged_value: Option<f64>,
-    /// For temporary edit of a [`DragValue`] value.
-    /// Couples with the current focus id.
-    edit_string: Option<String>,
-}
-
-impl MonoState {
-    pub(crate) fn end_frame(&mut self, input: &InputState) {
-        if input.pointer.any_pressed() || input.pointer.any_released() {
-            self.last_dragged_id = None;
-            self.last_dragged_value = None;
-        }
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-type NumFormatter<'a> = Box<dyn 'a + Fn(f64, RangeInclusive<usize>) -> String>;
-type NumParser<'a> = Box<dyn 'a + Fn(&str) -> Option<f64>>;
-
-// ----------------------------------------------------------------------------
-
-/// Combined into one function (rather than two) to make it easier
-/// for the borrow checker.
-type GetSetValue<'a> = Box<dyn 'a + FnMut(Option<f64>) -> f64>;
-
-fn get(get_set_value: &mut GetSetValue<'_>) -> f64 {
-    (get_set_value)(None)
-}
-
-fn set(get_set_value: &mut GetSetValue<'_>, value: f64) {
-    (get_set_value)(Some(value));
-}
-
-/// A numeric value that you can change by dragging the number. More compact than a [`Slider`].
-///
-/// ```
-/// # egui::__run_test_ui(|ui| {
-/// # let mut my_f32: f32 = 0.0;
-/// ui.add(egui::DragValue::new(&mut my_f32).speed(0.1));
-/// # });
-/// ```
-#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
-pub struct DragValue<'a> {
-    get_set_value: GetSetValue<'a>,
-    speed: f64,
-    prefix: String,
-    suffix: String,
-    clamp_range: RangeInclusive<f64>,
-    min_decimals: usize,
-    max_decimals: Option<usize>,
-    custom_formatter: Option<NumFormatter<'a>>,
-    custom_parser: Option<NumParser<'a>>,
-}
-
-impl<'a> DragValue<'a> {
-    pub fn new<Num: emath::Numeric>(value: &'a mut Num) -> Self {
-        let slf = Self::from_get_set(move |v: Option<f64>| {
-            if let Some(v) = v {
-                *value = Num::from_f64(v);
-            }
-            value.to_f64()
-        });
-
-        if Num::INTEGRAL {
-            slf.max_decimals(0)
-                .clamp_range(Num::MIN..=Num::MAX)
-                .speed(0.25)
-        } else {
-            slf
-        }
-    }
-
-    pub fn from_get_set(get_set_value: impl 'a + FnMut(Option<f64>) -> f64) -> Self {
-        Self {
-            get_set_value: Box::new(get_set_value),
-            speed: 1.0,
-            prefix: Default::default(),
-            suffix: Default::default(),
-            clamp_range: f64::NEG_INFINITY..=f64::INFINITY,
-            min_decimals: 0,
-            max_decimals: None,
-            custom_formatter: None,
-            custom_parser: None,
-        }
-    }
-
-    /// How much the value changes when dragged one point (logical pixel).
-    pub fn speed(mut self, speed: impl Into<f64>) -> Self {
-        self.speed = speed.into();
-        self
-    }
-
-    /// Clamp incoming and outgoing values to this range.
-    pub fn clamp_range<Num: emath::Numeric>(mut self, clamp_range: RangeInclusive<Num>) -> Self {
-        self.clamp_range = clamp_range.start().to_f64()..=clamp_range.end().to_f64();
-        self
-    }
-
-    /// Show a prefix before the number, e.g. "x: "
-    pub fn prefix(mut self, prefix: impl ToString) -> Self {
-        self.prefix = prefix.to_string();
-        self
-    }
-
-    /// Add a suffix to the number, this can be e.g. a unit ("°" or " m")
-    pub fn suffix(mut self, suffix: impl ToString) -> Self {
-        self.suffix = suffix.to_string();
-        self
-    }
-
-    // TODO(emilk): we should also have a "min precision".
-    /// Set a minimum number of decimals to display.
-    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
-    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
-    pub fn min_decimals(mut self, min_decimals: usize) -> Self {
-        self.min_decimals = min_decimals;
-        self
-    }
-
-    // TODO(emilk): we should also have a "max precision".
-    /// Set a maximum number of decimals to display.
-    /// Values will also be rounded to this number of decimals.
-    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
-    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
-    pub fn max_decimals(mut self, max_decimals: usize) -> Self {
-        self.max_decimals = Some(max_decimals);
-        self
-    }
-
-    pub fn max_decimals_opt(mut self, max_decimals: Option<usize>) -> Self {
-        self.max_decimals = max_decimals;
-        self
-    }
-
-    /// Set an exact number of decimals to display.
-    /// Values will also be rounded to this number of decimals.
-    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
-    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
-    pub fn fixed_decimals(mut self, num_decimals: usize) -> Self {
-        self.min_decimals = num_decimals;
-        self.max_decimals = Some(num_decimals);
-        self
-    }
-
-    /// Set custom formatter defining how numbers are converted into text.
-    ///
-    /// A custom formatter takes a `f64` for the numeric value and a `RangeInclusive<usize>` representing
-    /// the decimal range i.e. minimum and maximum number of decimal places shown.
-    ///
-    /// See also: [`DragValue::custom_parser`]
-    ///
-    /// ```
-    /// # egui::__run_test_ui(|ui| {
-    /// # let mut my_i32: i32 = 0;
-    /// ui.add(egui::DragValue::new(&mut my_i32)
-    ///     .clamp_range(0..=((60 * 60 * 24) - 1))
-    ///     .custom_formatter(|n, _| {
-    ///         let n = n as i32;
-    ///         let hours = n / (60 * 60);
-    ///         let mins = (n / 60) % 60;
-    ///         let secs = n % 60;
-    ///         format!("{hours:02}:{mins:02}:{secs:02}")
-    ///     })
-    ///     .custom_parser(|s| {
-    ///         let parts: Vec<&str> = s.split(':').collect();
-    ///         if parts.len() == 3 {
-    ///             parts[0].parse::<i32>().and_then(|h| {
-    ///                 parts[1].parse::<i32>().and_then(|m| {
-    ///                     parts[2].parse::<i32>().map(|s| {
-    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
-    ///                     })
-    ///                 })
-    ///             })
-    ///             .ok()
-    ///         } else {
-    ///             None
-    ///         }
-    ///     }));
-    /// # });
-    /// ```
-    pub fn custom_formatter(
-        mut self,
-        formatter: impl 'a + Fn(f64, RangeInclusive<usize>) -> String,
-    ) -> Self {
-        self.custom_formatter = Some(Box::new(formatter));
-        self
-    }
-
-    /// Set custom parser defining how the text input is parsed into a number.
-    ///
-    /// A custom parser takes an `&str` to parse into a number and returns a `f64` if it was successfully parsed
-    /// or `None` otherwise.
-    ///
-    /// See also: [`DragValue::custom_formatter`]
-    ///
-    /// ```
-    /// # egui::__run_test_ui(|ui| {
-    /// # let mut my_i32: i32 = 0;
-    /// ui.add(egui::DragValue::new(&mut my_i32)
-    ///     .clamp_range(0..=((60 * 60 * 24) - 1))
-    ///     .custom_formatter(|n, _| {
-    ///         let n = n as i32;
-    ///         let hours = n / (60 * 60);
-    ///         let mins = (n / 60) % 60;
-    ///         let secs = n % 60;
-    ///         format!("{hours:02}:{mins:02}:{secs:02}")
-    ///     })
-    ///     .custom_parser(|s| {
-    ///         let parts: Vec<&str> = s.split(':').collect();
-    ///         if parts.len() == 3 {
-    ///             parts[0].parse::<i32>().and_then(|h| {
-    ///                 parts[1].parse::<i32>().and_then(|m| {
-    ///                     parts[2].parse::<i32>().map(|s| {
-    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
-    ///                     })
-    ///                 })
-    ///             })
-    ///             .ok()
-    ///         } else {
-    ///             None
-    ///         }
-    ///     }));
-    /// # });
-    /// ```
-    pub fn custom_parser(mut self, parser: impl 'a + Fn(&str) -> Option<f64>) -> Self {
-        self.custom_parser = Some(Box::new(parser));
-        self
-    }
-
-    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as binary integers. Floating point
-    /// numbers are *not* supported.
-    ///
-    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
-    /// prefixed with additional 0s to match `min_width`.
-    ///
-    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
-    /// they will be prefixed with a '-' sign.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `min_width` is 0.
-    ///
-    /// ```
-    /// # egui::__run_test_ui(|ui| {
-    /// # let mut my_i32: i32 = 0;
-    /// ui.add(egui::DragValue::new(&mut my_i32).binary(64, false));
-    /// # });
-    /// ```
-    pub fn binary(self, min_width: usize, twos_complement: bool) -> Self {
-        assert!(
-            min_width > 0,
-            "DragValue::binary: `min_width` must be greater than 0"
-        );
-        if twos_complement {
-            self.custom_formatter(move |n, _| format!("{:0>min_width$b}", n as i64))
-        } else {
-            self.custom_formatter(move |n, _| {
-                let sign = if n < 0.0 { "-" } else { "" };
-                format!("{sign}{:0>min_width$b}", n.abs() as i64)
-            })
-        }
-        .custom_parser(|s| i64::from_str_radix(s, 2).map(|n| n as f64).ok())
-    }
-
-    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as octal integers. Floating point
-    /// numbers are *not* supported.
-    ///
-    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
-    /// prefixed with additional 0s to match `min_width`.
-    ///
-    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
-    /// they will be prefixed with a '-' sign.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `min_width` is 0.
-    ///
-    /// ```
-    /// # egui::__run_test_ui(|ui| {
-    /// # let mut my_i32: i32 = 0;
-    /// ui.add(egui::DragValue::new(&mut my_i32).octal(22, false));
-    /// # });
-    /// ```
-    pub fn octal(self, min_width: usize, twos_complement: bool) -> Self {
-        assert!(
-            min_width > 0,
-            "DragValue::octal: `min_width` must be greater than 0"
-        );
-        if twos_complement {
-            self.custom_formatter(move |n, _| format!("{:0>min_width$o}", n as i64))
-        } else {
-            self.custom_formatter(move |n, _| {
-                let sign = if n < 0.0 { "-" } else { "" };
-                format!("{sign}{:0>min_width$o}", n.abs() as i64)
-            })
-        }
-        .custom_parser(|s| i64::from_str_radix(s, 8).map(|n| n as f64).ok())
-    }
-
-    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as hexadecimal integers. Floating point
-    /// numbers are *not* supported.
-    ///
-    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
-    /// prefixed with additional 0s to match `min_width`.
-    ///
-    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
-    /// they will be prefixed with a '-' sign.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `min_width` is 0.
-    ///
-    /// ```
-    /// # egui::__run_test_ui(|ui| {
-    /// # let mut my_i32: i32 = 0;
-    /// ui.add(egui::DragValue::new(&mut my_i32).hexadecimal(16, false, true));
-    /// # });
-    /// ```
-    pub fn hexadecimal(self, min_width: usize, twos_complement: bool, upper: bool) -> Self {
-        assert!(
-            min_width > 0,
-            "DragValue::hexadecimal: `min_width` must be greater than 0"
-        );
-        match (twos_complement, upper) {
-            (true, true) => {
-                self.custom_formatter(move |n, _| format!("{:0>min_width$X}", n as i64))
-            }
-            (true, false) => {
-                self.custom_formatter(move |n, _| format!("{:0>min_width$x}", n as i64))
-            }
-            (false, true) => self.custom_formatter(move |n, _| {
-                let sign = if n < 0.0 { "-" } else { "" };
-                format!("{sign}{:0>min_width$X}", n.abs() as i64)
-            }),
-            (false, false) => self.custom_formatter(move |n, _| {
-                let sign = if n < 0.0 { "-" } else { "" };
-                format!("{sign}{:0>min_width$x}", n.abs() as i64)
-            }),
-        }
-        .custom_parser(|s| i64::from_str_radix(s, 16).map(|n| n as f64).ok())
-    }
-}
-
-impl<'a> Widget for DragValue<'a> {
-    fn ui(self, ui: &mut Ui) -> Response {
-        let Self {
-            mut get_set_value,
-            speed,
-            clamp_range,
-            prefix,
-            suffix,
-            min_decimals,
-            max_decimals,
-            custom_formatter,
-            custom_parser,
-        } = self;
-
-        let shift = ui.input(|i| i.modifiers.shift_only());
-        // The widget has the same ID whether it's in edit or button mode.
-        let id = ui.next_auto_id();
-        let is_slow_speed = shift && ui.memory(|mem| mem.is_being_dragged(id));
-
-        // The following ensures that when a `DragValue` receives focus,
-        // it is immediately rendered in edit mode, rather than being rendered
-        // in button mode for just one frame. This is important for
-        // screen readers.
-        let is_kb_editing = ui.memory_mut(|mem| {
-            mem.interested_in_focus(id);
-            let is_kb_editing = mem.has_focus(id);
-            if mem.gained_focus(id) {
-                mem.drag_value.edit_string = None;
-            }
-            is_kb_editing
-        });
-
-        let old_value = get(&mut get_set_value);
-        let mut value = old_value;
-        let aim_rad = ui.input(|i| i.aim_radius() as f64);
-
-        let auto_decimals = (aim_rad / speed.abs()).log10().ceil().clamp(0.0, 15.0) as usize;
-        let auto_decimals = auto_decimals + is_slow_speed as usize;
-        let max_decimals = max_decimals.unwrap_or(auto_decimals + 2);
-        let auto_decimals = auto_decimals.clamp(min_decimals, max_decimals);
-
-        let change = ui.input_mut(|input| {
-            let mut change = 0.0;
-
-            if is_kb_editing {
-                // This deliberately doesn't listen for left and right arrow keys,
-                // because when editing, these are used to move the caret.
-                // This behavior is consistent with other editable spinner/stepper
-                // implementations, such as Chromium's (for HTML5 number input).
-                // It is also normal for such controls to go directly into edit mode
-                // when they receive keyboard focus, and some screen readers
-                // assume this behavior, so having a separate mode for incrementing
-                // and decrementing, that supports all arrow keys, would be
-                // problematic.
-                change += input.count_and_consume_key(Modifiers::NONE, Key::ArrowUp) as f64
-                    - input.count_and_consume_key(Modifiers::NONE, Key::ArrowDown) as f64;
-            }
-
-            #[cfg(feature = "accesskit")]
-            {
-                use accesskit::Action;
-                change += input.num_accesskit_action_requests(id, Action::Increment) as f64
-                    - input.num_accesskit_action_requests(id, Action::Decrement) as f64;
-            }
-
-            change
-        });
-
-        #[cfg(feature = "accesskit")]
-        {
-            use accesskit::{Action, ActionData};
-            ui.input(|input| {
-                for request in input.accesskit_action_requests(id, Action::SetValue) {
-                    if let Some(ActionData::NumericValue(new_value)) = request.data {
-                        value = new_value;
-                    }
-                }
-            });
-        }
-
-        if change != 0.0 {
-            value += speed * change;
-            value = emath::round_to_decimals(value, auto_decimals);
-        }
-
-        value = clamp_to_range(value, clamp_range.clone());
-        if old_value != value {
-            set(&mut get_set_value, value);
-            ui.memory_mut(|mem| mem.drag_value.edit_string = None);
-        }
-
-        let value_text = match custom_formatter {
-            Some(custom_formatter) => custom_formatter(value, auto_decimals..=max_decimals),
-            None => {
-                if value == 0.0 {
-                    "0".to_owned()
-                } else {
-                    emath::format_with_decimals_in_range(value, auto_decimals..=max_decimals)
-                }
-            }
-        };
-
-        let text_style = ui.style().drag_value_text_style.clone();
-
-        // some clones below are redundant if AccessKit is disabled
-        #[allow(clippy::redundant_clone)]
-        let mut response = if is_kb_editing {
-            let mut value_text = ui
-                .memory_mut(|mem| mem.drag_value.edit_string.take())
-                .unwrap_or_else(|| value_text.clone());
-            let response = ui.add(
-                TextEdit::singleline(&mut value_text)
-                    .clip_text(false)
-                    .horizontal_align(ui.layout().horizontal_align())
-                    .vertical_align(ui.layout().vertical_align())
-                    .margin(ui.spacing().button_padding)
-                    .min_size(ui.spacing().interact_size)
-                    .id(id)
-                    .desired_width(ui.spacing().interact_size.x)
-                    .font(text_style),
-            );
-            // Only update the value when the user presses enter, or clicks elsewhere. NOT every frame.
-            // See https://github.com/emilk/egui/issues/2687
-            if response.lost_focus() {
-                let parsed_value = match custom_parser {
-                    Some(parser) => parser(&value_text),
-                    None => value_text.parse().ok(),
-                };
-                if let Some(parsed_value) = parsed_value {
-                    let parsed_value = clamp_to_range(parsed_value, clamp_range.clone());
-                    set(&mut get_set_value, parsed_value);
-                }
-            }
-            ui.memory_mut(|mem| mem.drag_value.edit_string = Some(value_text));
-            response
-        } else {
-            let button = Button::new(
-                RichText::new(format!("{}{}{}", prefix, value_text.clone(), suffix))
-                    .text_style(text_style),
-            )
-            .wrap(false)
-            .sense(Sense::click_and_drag())
-            .min_size(ui.spacing().interact_size); // TODO(emilk): find some more generic solution to `min_size`
-
-            let response = ui.add(button);
-            let mut response = response.on_hover_cursor(CursorIcon::ResizeHorizontal);
-
-            if ui.style().explanation_tooltips {
-                response = response .on_hover_text(format!(
-                    "{}{}{}\nDrag to edit or click to enter a value.\nPress 'Shift' while dragging for better control.",
-                    prefix,
-                    value as f32, // Show full precision value on-hover. TODO(emilk): figure out f64 vs f32
-                    suffix
-                ));
-            }
-
-            if response.clicked() {
-                ui.memory_mut(|mem| {
-                    mem.drag_value.edit_string = None;
-                    mem.request_focus(id);
-                });
-                let mut state = TextEdit::load_state(ui.ctx(), id).unwrap_or_default();
-                state.set_ccursor_range(Some(text::CCursorRange::two(
-                    epaint::text::cursor::CCursor::default(),
-                    epaint::text::cursor::CCursor::new(value_text.chars().count()),
-                )));
-                state.store(ui.ctx(), response.id);
-            } else if response.dragged() {
-                ui.ctx().set_cursor_icon(CursorIcon::ResizeHorizontal);
-
-                let mdelta = response.drag_delta();
-                let delta_points = mdelta.x - mdelta.y; // Increase to the right and up
-
-                let speed = if is_slow_speed { speed / 10.0 } else { speed };
-
-                let delta_value = delta_points as f64 * speed;
-
-                if delta_value != 0.0 {
-                    let mut drag_state = ui.memory_mut(|mem| std::mem::take(&mut mem.drag_value));
-
-                    // Since we round the value being dragged, we need to store the full precision value in memory:
-                    let stored_value = (drag_state.last_dragged_id == Some(response.id))
-                        .then_some(drag_state.last_dragged_value)
-                        .flatten();
-                    let stored_value = stored_value.unwrap_or(value);
-                    let stored_value = stored_value + delta_value;
-
-                    let aim_delta = aim_rad * speed;
-                    let rounded_new_value = emath::smart_aim::best_in_range_f64(
-                        stored_value - aim_delta,
-                        stored_value + aim_delta,
-                    );
-                    let rounded_new_value =
-                        emath::round_to_decimals(rounded_new_value, auto_decimals);
-                    let rounded_new_value = clamp_to_range(rounded_new_value, clamp_range.clone());
-                    set(&mut get_set_value, rounded_new_value);
-
-                    drag_state.last_dragged_id = Some(response.id);
-                    drag_state.last_dragged_value = Some(stored_value);
-                    ui.memory_mut(|mem| mem.drag_value = drag_state);
-                }
-            }
-
-            response
-        };
-
-        response.changed = get(&mut get_set_value) != old_value;
-
-        response.widget_info(|| WidgetInfo::drag_value(value));
-
-        #[cfg(feature = "accesskit")]
-        ui.ctx().accesskit_node_builder(response.id, |builder| {
-            use accesskit::Action;
-            // If either end of the range is unbounded, it's better
-            // to leave the corresponding AccessKit field set to None,
-            // to allow for platform-specific default behavior.
-            if clamp_range.start().is_finite() {
-                builder.set_min_numeric_value(*clamp_range.start());
-            }
-            if clamp_range.end().is_finite() {
-                builder.set_max_numeric_value(*clamp_range.end());
-            }
-            builder.set_numeric_value_step(speed);
-            builder.add_action(Action::SetValue);
-            if value < *clamp_range.end() {
-                builder.add_action(Action::Increment);
-            }
-            if value > *clamp_range.start() {
-                builder.add_action(Action::Decrement);
-            }
-            // The name field is set to the current value by the button,
-            // but we don't want it set that way on this widget type.
-            builder.clear_name();
-            // Always expose the value as a string. This makes the widget
-            // more stable to accessibility users as it switches
-            // between edit and button modes. This is particularly important
-            // for VoiceOver on macOS; if the value is not exposed as a string
-            // when the widget is in button mode, then VoiceOver speaks
-            // the value (or a percentage if the widget has a clamp range)
-            // when the widget loses focus, overriding the announcement
-            // of the newly focused widget. This is certainly a VoiceOver bug,
-            // but it's good to make our software work as well as possible
-            // with existing assistive technology. However, if the widget
-            // has a prefix and/or suffix, expose those when in button mode,
-            // just as they're exposed on the screen. This triggers the
-            // VoiceOver bug just described, but exposing all information
-            // is more important, and at least we can avoid the bug
-            // for instances of the widget with no prefix or suffix.
-            //
-            // The value is exposed as a string by the text edit widget
-            // when in edit mode.
-            if !is_kb_editing {
-                let value_text = format!("{}{}{}", prefix, value_text, suffix);
-                builder.set_value(value_text);
-            }
-        });
-
-        response
-    }
-}
-
-fn clamp_to_range(x: f64, range: RangeInclusive<f64>) -> f64 {
-    let (mut min, mut max) = (*range.start(), *range.end());
-
-    if min.total_cmp(&max) == Ordering::Greater {
-        (min, max) = (max, min);
-    }
-
-    match x.total_cmp(&min) {
-        Ordering::Less | Ordering::Equal => min,
-        Ordering::Greater => match x.total_cmp(&max) {
-            Ordering::Greater | Ordering::Equal => max,
-            Ordering::Less => x,
-        },
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::clamp_to_range;
-
-    macro_rules! total_assert_eq {
-        ($a:expr, $b:expr) => {
-            assert!(
-                matches!($a.total_cmp(&$b), std::cmp::Ordering::Equal),
-                "{} != {}",
-                $a,
-                $b
-            );
-        };
-    }
-
-    #[test]
-    fn test_total_cmp_clamp_to_range() {
-        total_assert_eq!(0.0_f64, clamp_to_range(-0.0, 0.0..=f64::MAX));
-        total_assert_eq!(-0.0_f64, clamp_to_range(0.0, -1.0..=-0.0));
-        total_assert_eq!(-1.0_f64, clamp_to_range(-25.0, -1.0..=1.0));
-        total_assert_eq!(5.0_f64, clamp_to_range(5.0, -1.0..=10.0));
-        total_assert_eq!(15.0_f64, clamp_to_range(25.0, -1.0..=15.0));
-        total_assert_eq!(1.0_f64, clamp_to_range(1.0, 1.0..=10.0));
-        total_assert_eq!(10.0_f64, clamp_to_range(10.0, 1.0..=10.0));
-        total_assert_eq!(5.0_f64, clamp_to_range(5.0, 10.0..=1.0));
-        total_assert_eq!(5.0_f64, clamp_to_range(15.0, 5.0..=1.0));
-        total_assert_eq!(1.0_f64, clamp_to_range(-5.0, 5.0..=1.0));
-    }
-}

crates/egui_demo_app/src/lib.rs

@@ -1,80 +0,0 @@
-//! Demo app for egui
-#![allow(clippy::missing_errors_doc)]
-
-mod apps;
-mod backend_panel;
-pub(crate) mod frame_history;
-mod wrap_app;
-
-#[cfg(target_arch = "wasm32")]
-use eframe::web::AppRunnerRef;
-
-pub use wrap_app::WrapApp;
-
-/// Time of day as seconds since midnight. Used for clock in demo app.
-pub(crate) fn seconds_since_midnight() -> f64 {
-    use chrono::Timelike;
-    let time = chrono::Local::now().time();
-    time.num_seconds_from_midnight() as f64 + 1e-9 * (time.nanosecond() as f64)
-}
-
-// ----------------------------------------------------------------------------
-
-#[cfg(target_arch = "wasm32")]
-use eframe::wasm_bindgen::{self, prelude::*};
-
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-pub struct WebHandle {
-    handle: AppRunnerRef,
-}
-
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-impl WebHandle {
-    #[wasm_bindgen]
-    pub fn stop_web(&self) -> Result<(), wasm_bindgen::JsValue> {
-        let mut app = self.handle.lock();
-        app.destroy()
-    }
-
-    #[wasm_bindgen]
-    pub fn set_some_content_from_javasript(&mut self, _some_data: &str) {
-        let _app = self.handle.lock().app_mut::<WrapApp>();
-        // _app.data = some_data;
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-pub fn init_wasm_hooks() {
-    // Make sure panics are logged using `console.error`.
-    console_error_panic_hook::set_once();
-
-    // Redirect tracing to console.log and friends:
-    tracing_wasm::set_as_global_default();
-}
-
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-pub async fn start_separate(canvas_id: &str) -> Result<WebHandle, wasm_bindgen::JsValue> {
-    let web_options = eframe::WebOptions::default();
-    eframe::start_web(
-        canvas_id,
-        web_options,
-        Box::new(|cc| Box::new(WrapApp::new(cc))),
-    )
-    .await
-    .map(|handle| WebHandle { handle })
-}
-
-/// This is the entry-point for all the web-assembly.
-/// This is called once from the HTML.
-/// It loads the app, installs some callbacks, then returns.
-/// You can add more callbacks like this if you want to call in to your code.
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-pub async fn start(canvas_id: &str) -> Result<WebHandle, wasm_bindgen::JsValue> {
-    init_wasm_hooks();
-    start_separate(canvas_id).await
-}

crates/egui_demo_lib/src/demo/highlighting.rs

@@ -1,37 +0,0 @@
-#[derive(Default)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(default))]
-pub struct Highlighting {}
-
-impl super::Demo for Highlighting {
-    fn name(&self) -> &'static str {
-        "Highlighting"
-    }
-
-    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
-        egui::Window::new(self.name())
-            .default_width(320.0)
-            .open(open)
-            .show(ctx, |ui| {
-                use super::View as _;
-                self.ui(ui);
-            });
-    }
-}
-
-impl super::View for Highlighting {
-    fn ui(&mut self, ui: &mut egui::Ui) {
-        ui.label("This demo demonstrates highlighting a widget.");
-        ui.add_space(4.0);
-        let label_response = ui.label("Hover me to highlight the button!");
-        ui.add_space(4.0);
-        let mut button_response = ui.button("Hover the button to highlight the label!");
-
-        if label_response.hovered() {
-            button_response = button_response.highlight();
-        }
-        if button_response.hovered() {
-            label_response.highlight();
-        }
-    }
-}

crates/egui_extras/CHANGELOG.md

@@ -1,44 +0,0 @@
-# Changelog for egui_extras
-All notable changes to the `egui_extras` integration will be noted in this file.
-
-
-## Unreleased
-
-
-## 0.21.0 - 2023-02-08
-* Update to egui 0.21
-
-
-## 0.20.0 - 2022-12-08
-* Added `RetainedImage::from_svg_bytes_with_size` to be able to specify a size for SVGs to be rasterized at.
-* Lots of `Table` improvements ([#2369](https://github.com/emilk/egui/pull/2369)):
-    * Double-click column separators to auto-size the column.
-    * All `Table` now store state. You may see warnings about reused table ids. Use `ui.push_id` to fix this.
-    * `TableBuilder::column` takes a `Column` instead of a `Size`.
-    * `Column` controls default size, size range, resizing, and clipping of columns.
-    * `Column::auto` will pick a size automatically
-    * Added `Table::scroll_to_row`.
-    * Added `Table::min_scrolled_height` and `Table::max_scroll_height`.
-    * Added `TableBody::max_size`.
-    * `Table::scroll` renamed to `Table::vscroll`.
-    * `egui_extras::Strip` now has `clip: false` by default.
-    * Fix bugs when putting `Table` inside of a horizontal `ScrollArea`.
-    * Many other bug fixes.
-* Add `Table::auto_shrink` - set to `false` to expand table to fit its containing `Ui` ([#2371](https://github.com/emilk/egui/pull/2371)).
-* Added `TableBuilder::vertical_scroll_offset`: method to set vertical scroll offset position for a table ([#1946](https://github.com/emilk/egui/pull/1946)).
-
-
-## 0.19.0 - 2022-08-20
-* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
-* You can now specify a texture filter for `RetainedImage` ([#1636](https://github.com/emilk/egui/pull/1636)).
-* Fixed uneven `Table` striping ([#1680](https://github.com/emilk/egui/pull/1680)).
-
-
-## 0.18.0 - 2022-04-30
-* Added `Strip`, `Table` and `DatePicker` ([#963](https://github.com/emilk/egui/pull/963)).
-* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
-* Renamed feature "persistence" to "serde" ([#1540](https://github.com/emilk/egui/pull/1540)).
-
-
-## 0.17.0 - 2022-02-22
-* `RetainedImage`: convenience for loading svg, png, jpeg etc and showing them in egui.

crates/egui_glium/src/shader/fragment_120.glsl

@@ -1,31 +0,0 @@
-#version 120
-
-uniform sampler2D u_sampler;
-varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
-varying vec2 v_tc;
-
-// 0-255 sRGB  from  0-1 linear
-vec3 srgb_from_linear(vec3 rgb) {
-    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
-    vec3 lower = rgb * vec3(3294.6);
-    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
-    return mix(higher, lower, vec3(cutoff));
-}
-
-// 0-255 sRGBA  from  0-1 linear
-vec4 srgba_from_linear(vec4 rgba) {
-    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
-}
-
-// 0-1 gamma  from  0-1 linear
-vec4 gamma_from_linear_rgba(vec4 linear_rgba) {
-    return vec4(srgb_from_linear(linear_rgba.rgb) / 255.0, linear_rgba.a);
-}
-
-void main() {
-    // The texture is set up with `SRGB8_ALPHA8`
-    vec4 texture_in_gamma = gamma_from_linear_rgba(texture2D(u_sampler, v_tc));
-
-    // Multiply vertex color with texture color (in gamma space).
-    gl_FragColor = v_rgba_gamma * texture_in_gamma;
-}

crates/egui_glium/src/shader/fragment_140.glsl

@@ -1,32 +0,0 @@
-#version 140
-
-uniform sampler2D u_sampler;
-in vec4 v_rgba_gamma;
-in vec2 v_tc;
-out vec4 f_color;
-
-// 0-255 sRGB  from  0-1 linear
-vec3 srgb_from_linear(vec3 rgb) {
-    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
-    vec3 lower = rgb * vec3(3294.6);
-    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
-    return mix(higher, lower, vec3(cutoff));
-}
-
-// 0-255 sRGBA  from  0-1 linear
-vec4 srgba_from_linear(vec4 rgba) {
-    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
-}
-
-// 0-1 gamma  from  0-1 linear
-vec4 gamma_from_linear_rgba(vec4 linear_rgba) {
-    return vec4(srgb_from_linear(linear_rgba.rgb) / 255.0, linear_rgba.a);
-}
-
-void main() {
-    // The texture is set up with `SRGB8_ALPHA8`
-    vec4 texture_in_gamma = gamma_from_linear_rgba(texture(u_sampler, v_tc));
-
-    // Multiply vertex color with texture color (in gamma space).
-    f_color = v_rgba_gamma * texture_in_gamma;
-}

crates/egui_glium/src/shader/vertex_100es.glsl

@@ -1,19 +0,0 @@
-#version 100
-
-precision mediump float;
-uniform vec2 u_screen_size;
-attribute vec2 a_pos;
-attribute vec2 a_tc;
-attribute vec4 a_srgba;
-varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
-varying vec2 v_tc;
-
-void main() {
-    gl_Position = vec4(
-                      2.0 * a_pos.x / u_screen_size.x - 1.0,
-                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
-                      0.0,
-                      1.0);
-    v_rgba_gamma = a_srgba / 255.0;
-    v_tc = a_tc;
-}

crates/egui_glium/src/shader/vertex_120.glsl

@@ -1,18 +0,0 @@
-#version 120
-
-uniform vec2 u_screen_size;
-attribute vec2 a_pos;
-attribute vec4 a_srgba; // 0-255 sRGB
-attribute vec2 a_tc;
-varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
-varying vec2 v_tc;
-
-void main() {
-    gl_Position = vec4(
-                      2.0 * a_pos.x / u_screen_size.x - 1.0,
-                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
-                      0.0,
-                      1.0);
-    v_rgba_gamma = a_srgba / 255.0;
-    v_tc = a_tc;
-}

crates/egui_glium/src/shader/vertex_140.glsl

@@ -1,18 +0,0 @@
-#version 140
-
-uniform vec2 u_screen_size;
-in vec2 a_pos;
-in vec4 a_srgba; // 0-255 sRGB
-in vec2 a_tc;
-out vec4 v_rgba_gamma;
-out vec2 v_tc;
-
-void main() {
-    gl_Position = vec4(
-                      2.0 * a_pos.x / u_screen_size.x - 1.0,
-                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
-                      0.0,
-                      1.0);
-    v_rgba_gamma = a_srgba / 255.0;
-    v_tc = a_tc;
-}

crates/egui_glium/src/shader/vertex_300es.glsl

@@ -1,19 +0,0 @@
-#version 300 es
-
-precision mediump float;
-uniform vec2 u_screen_size;
-attribute vec2 a_pos;
-attribute vec2 a_tc;
-attribute vec4 a_srgba;
-varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
-varying vec2 v_tc;
-
-void main() {
-    gl_Position = vec4(
-                      2.0 * a_pos.x / u_screen_size.x - 1.0,
-                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
-                      0.0,
-                      1.0);
-    v_rgba_gamma = a_srgba / 255.0;
-    v_tc = a_tc;
-}

crates/egui_glow/examples/pure_glow.rs

@@ -1,255 +0,0 @@
-//! Example how to use pure `egui_glow`.
-
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-#![allow(unsafe_code)]
-
-use egui_winit::winit;
-
-/// The majority of `GlutinWindowContext` is taken from `eframe`
-struct GlutinWindowContext {
-    window: winit::window::Window,
-    gl_context: glutin::context::PossiblyCurrentContext,
-    gl_display: glutin::display::Display,
-    gl_surface: glutin::surface::Surface<glutin::surface::WindowSurface>,
-}
-
-impl GlutinWindowContext {
-    // refactor this function to use `glutin-winit` crate eventually.
-    // preferably add android support at the same time.
-    #[allow(unsafe_code)]
-    unsafe fn new(event_loop: &winit::event_loop::EventLoopWindowTarget<()>) -> Self {
-        use egui::NumExt;
-        use glutin::context::NotCurrentGlContextSurfaceAccessor;
-        use glutin::display::GetGlDisplay;
-        use glutin::display::GlDisplay;
-        use glutin::prelude::GlSurface;
-        use raw_window_handle::HasRawWindowHandle;
-        let winit_window_builder = winit::window::WindowBuilder::new()
-            .with_resizable(true)
-            .with_inner_size(winit::dpi::LogicalSize {
-                width: 800.0,
-                height: 600.0,
-            })
-            .with_title("egui_glow example") // Keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
-            .with_visible(false);
-
-        let config_template_builder = glutin::config::ConfigTemplateBuilder::new()
-            .prefer_hardware_accelerated(None)
-            .with_depth_size(0)
-            .with_stencil_size(0)
-            .with_transparency(false);
-
-        tracing::debug!("trying to get gl_config");
-        let (mut window, gl_config) =
-            glutin_winit::DisplayBuilder::new() // let glutin-winit helper crate handle the complex parts of opengl context creation
-                .with_preference(glutin_winit::ApiPrefence::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150
-                .with_window_builder(Some(winit_window_builder.clone()))
-                .build(
-                    event_loop,
-                    config_template_builder,
-                    |mut config_iterator| {
-                        config_iterator.next().expect(
-                            "failed to find a matching configuration for creating glutin config",
-                        )
-                    },
-                )
-                .expect("failed to create gl_config");
-        let gl_display = gl_config.display();
-        tracing::debug!("found gl_config: {:?}", &gl_config);
-
-        let raw_window_handle = window.as_ref().map(|w| w.raw_window_handle());
-        tracing::debug!("raw window handle: {:?}", raw_window_handle);
-        let context_attributes =
-            glutin::context::ContextAttributesBuilder::new().build(raw_window_handle);
-        // by default, glutin will try to create a core opengl context. but, if it is not available, try to create a gl-es context using this fallback attributes
-        let fallback_context_attributes = glutin::context::ContextAttributesBuilder::new()
-            .with_context_api(glutin::context::ContextApi::Gles(None))
-            .build(raw_window_handle);
-        let not_current_gl_context = unsafe {
-            gl_display
-                    .create_context(&gl_config, &context_attributes)
-                    .unwrap_or_else(|_| {
-                        tracing::debug!("failed to create gl_context with attributes: {:?}. retrying with fallback context attributes: {:?}",
-                            &context_attributes,
-                            &fallback_context_attributes);
-                        gl_config
-                            .display()
-                            .create_context(&gl_config, &fallback_context_attributes)
-                            .expect("failed to create context even with fallback attributes")
-                    })
-        };
-
-        // this is where the window is created, if it has not been created while searching for suitable gl_config
-        let window = window.take().unwrap_or_else(|| {
-            tracing::debug!("window doesn't exist yet. creating one now with finalize_window");
-            glutin_winit::finalize_window(event_loop, winit_window_builder.clone(), &gl_config)
-                .expect("failed to finalize glutin window")
-        });
-        let (width, height): (u32, u32) = window.inner_size().into();
-        let width = std::num::NonZeroU32::new(width.at_least(1)).unwrap();
-        let height = std::num::NonZeroU32::new(height.at_least(1)).unwrap();
-        let surface_attributes =
-            glutin::surface::SurfaceAttributesBuilder::<glutin::surface::WindowSurface>::new()
-                .build(window.raw_window_handle(), width, height);
-        tracing::debug!(
-            "creating surface with attributes: {:?}",
-            &surface_attributes
-        );
-        let gl_surface = unsafe {
-            gl_display
-                .create_window_surface(&gl_config, &surface_attributes)
-                .unwrap()
-        };
-        tracing::debug!("surface created successfully: {gl_surface:?}.making context current");
-        let gl_context = not_current_gl_context.make_current(&gl_surface).unwrap();
-
-        gl_surface
-            .set_swap_interval(
-                &gl_context,
-                glutin::surface::SwapInterval::Wait(std::num::NonZeroU32::new(1).unwrap()),
-            )
-            .unwrap();
-
-        GlutinWindowContext {
-            window,
-            gl_context,
-            gl_display,
-            gl_surface,
-        }
-    }
-
-    fn window(&self) -> &winit::window::Window {
-        &self.window
-    }
-
-    fn resize(&self, physical_size: winit::dpi::PhysicalSize<u32>) {
-        use glutin::surface::GlSurface;
-        self.gl_surface.resize(
-            &self.gl_context,
-            physical_size.width.try_into().unwrap(),
-            physical_size.height.try_into().unwrap(),
-        );
-    }
-
-    fn swap_buffers(&self) -> glutin::error::Result<()> {
-        use glutin::surface::GlSurface;
-        self.gl_surface.swap_buffers(&self.gl_context)
-    }
-
-    fn get_proc_address(&self, addr: &std::ffi::CStr) -> *const std::ffi::c_void {
-        use glutin::display::GlDisplay;
-        self.gl_display.get_proc_address(addr)
-    }
-}
-
-fn main() {
-    let mut clear_color = [0.1, 0.1, 0.1];
-
-    let event_loop = winit::event_loop::EventLoopBuilder::with_user_event().build();
-    let (gl_window, gl) = create_display(&event_loop);
-    let gl = std::sync::Arc::new(gl);
-
-    let mut egui_glow = egui_glow::EguiGlow::new(&event_loop, gl.clone(), None);
-
-    event_loop.run(move |event, _, control_flow| {
-        let mut redraw = || {
-            let mut quit = false;
-
-            let repaint_after = egui_glow.run(gl_window.window(), |egui_ctx| {
-                egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
-                    ui.heading("Hello World!");
-                    if ui.button("Quit").clicked() {
-                        quit = true;
-                    }
-                    ui.color_edit_button_rgb(&mut clear_color);
-                });
-            });
-
-            *control_flow = if quit {
-                winit::event_loop::ControlFlow::Exit
-            } else if repaint_after.is_zero() {
-                gl_window.window().request_redraw();
-                winit::event_loop::ControlFlow::Poll
-            } else if let Some(repaint_after_instant) =
-                std::time::Instant::now().checked_add(repaint_after)
-            {
-                winit::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
-            } else {
-                winit::event_loop::ControlFlow::Wait
-            };
-
-            {
-                unsafe {
-                    use glow::HasContext as _;
-                    gl.clear_color(clear_color[0], clear_color[1], clear_color[2], 1.0);
-                    gl.clear(glow::COLOR_BUFFER_BIT);
-                }
-
-                // draw things behind egui here
-
-                egui_glow.paint(gl_window.window());
-
-                // draw things on top of egui here
-
-                gl_window.swap_buffers().unwrap();
-                gl_window.window().set_visible(true);
-            }
-        };
-
-        match event {
-            // Platform-dependent event handlers to workaround a winit bug
-            // See: https://github.com/rust-windowing/winit/issues/987
-            // See: https://github.com/rust-windowing/winit/issues/1619
-            winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
-            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
-
-            winit::event::Event::WindowEvent { event, .. } => {
-                use winit::event::WindowEvent;
-                if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) {
-                    *control_flow = winit::event_loop::ControlFlow::Exit;
-                }
-
-                if let winit::event::WindowEvent::Resized(physical_size) = &event {
-                    gl_window.resize(*physical_size);
-                } else if let winit::event::WindowEvent::ScaleFactorChanged {
-                    new_inner_size, ..
-                } = &event
-                {
-                    gl_window.resize(**new_inner_size);
-                }
-
-                let event_response = egui_glow.on_event(&event);
-
-                if event_response.repaint {
-                    gl_window.window().request_redraw();
-                }
-            }
-            winit::event::Event::LoopDestroyed => {
-                egui_glow.destroy();
-            }
-            winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
-                ..
-            }) => {
-                gl_window.window().request_redraw();
-            }
-
-            _ => (),
-        }
-    });
-}
-
-fn create_display(
-    event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
-) -> (GlutinWindowContext, glow::Context) {
-    let glutin_window_context = unsafe { GlutinWindowContext::new(event_loop) };
-    let gl = unsafe {
-        glow::Context::from_loader_function(|s| {
-            let s = std::ffi::CString::new(s)
-                .expect("failed to construct C string from string for gl proc address");
-
-            glutin_window_context.get_proc_address(&s)
-        })
-    };
-
-    (glutin_window_context, gl)
-}

crates/egui_glow/src/shader/fragment.glsl

@@ -1,41 +0,0 @@
-#ifdef GL_ES
-    precision mediump float;
-#endif
-
-uniform sampler2D u_sampler;
-
-#if NEW_SHADER_INTERFACE
-    in vec4 v_rgba_in_gamma;
-    in vec2 v_tc;
-    out vec4 f_color;
-    // a dirty hack applied to support webGL2
-    #define gl_FragColor f_color
-    #define texture2D texture
-#else
-    varying vec4 v_rgba_in_gamma;
-    varying vec2 v_tc;
-#endif
-
-// 0-1 sRGB gamma  from  0-1 linear
-vec3 srgb_gamma_from_linear(vec3 rgb) {
-    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
-    vec3 lower = rgb * vec3(12.92);
-    vec3 higher = vec3(1.055) * pow(rgb, vec3(1.0 / 2.4)) - vec3(0.055);
-    return mix(higher, lower, vec3(cutoff));
-}
-
-// 0-1 sRGBA gamma  from  0-1 linear
-vec4 srgba_gamma_from_linear(vec4 rgba) {
-    return vec4(srgb_gamma_from_linear(rgba.rgb), rgba.a);
-}
-
-void main() {
-#if SRGB_TEXTURES
-    vec4 texture_in_gamma = srgba_gamma_from_linear(texture2D(u_sampler, v_tc));
-#else
-    vec4 texture_in_gamma = texture2D(u_sampler, v_tc);
-#endif
-
-    // We multiply the colors in gamma space, because that's the only way to get text to look right.
-    gl_FragColor = v_rgba_in_gamma * texture_in_gamma;
-}

crates/egui_web/README.md

@@ -1 +0,0 @@
-`egui_web` used to be a standalone crate, but has now been moved into [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).

crates/emath/README.md

@@ -1,11 +0,0 @@
-# emath - egui math library
-
-[![Latest version](https://img.shields.io/crates/v/emath.svg)](https://crates.io/crates/emath)
-[![Documentation](https://docs.rs/emath/badge.svg)](https://docs.rs/emath)
-[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
-![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
-
-A bare-bones 2D math library with types and functions useful for GUI building.
-
-Made for [`egui`](https://github.com/emilk/egui/).

crates/epaint/README.md

@@ -1,11 +0,0 @@
-# epaint - egui paint library
-
-[![Latest version](https://img.shields.io/crates/v/epaint.svg)](https://crates.io/crates/epaint)
-[![Documentation](https://docs.rs/epaint/badge.svg)](https://docs.rs/epaint)
-[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
-![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
-
-A bare-bones 2D graphics library for turning simple 2D shapes and text into textured triangles.
-
-Made for [`egui`](https://github.com/emilk/egui/).

deny.toml

@@ -3,7 +3,6 @@
 targets = [
     { triple = "aarch64-apple-darwin" },
     { triple = "aarch64-linux-android" },
-    { triple = "wasm32-unknown-unknown" },
     { triple = "x86_64-apple-darwin" },
     { triple = "x86_64-pc-windows-msvc" },
     { triple = "x86_64-unknown-linux-gnu" },
@@ -24,29 +23,22 @@ ignore = [
 multiple-versions = "deny"
 wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
 deny = [
-    { name = "cmake" },       # Lord no
-    { name = "openssl-sys" }, # prefer rustls
     { name = "openssl" },     # prefer rustls
+    { name = "openssl-sys" }, # prefer rustls
 ]
 
 skip = [
     { name = "ahash" },      # old version via dark-light
     { name = "arrayvec" },   # old version via tiny-skiaz
     { name = "hashbrown" },  # old version via dark-light
-    { name = "nix" },                 # old version via winit
     { name = "time" },       # old version pulled in by unmaintianed crate 'chrono'
-    { name = "tiny-skia" },           # winit uses a different version from egui_extras (TODO(emilk): update egui_extras!)
     { name = "ttf-parser" }, # different versions pulled in by ab_glyph and usvg
-    { name = "wayland-sys" },         # old version via winit
-    { name = "windows_x86_64_msvc" }, # old version via glutin
-    { name = "windows-sys" },         # old version via glutin
-    { name = "windows" },             # old version via accesskit
 ]
 skip-tree = [
-    { name = "criterion" },     # dev-dependency
+    { name = "criterion" }, # dev-dependnecy
-    { name = "darling" },       # old version via tts
+    { name = "glium" },     # legacy crate, lots of old dependencies
-    { name = "foreign-types" }, # old version from wgpu
     { name = "rfd" },       # example dependency
+    { name = "three-d" },   # example dependency
 ]
 
 
@@ -56,18 +48,16 @@ allow-osi-fsf-free = "neither"
 confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
 copyleft = "deny"
 allow = [
+    # "Apache-2.0 WITH LLVM-exception", # https://spdx.org/licenses/LLVM-exception.html
     "Apache-2.0",   # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
     "BSD-2-Clause", # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
     "BSD-3-Clause", # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
     "BSL-1.0",      # https://tldrlegal.com/license/boost-software-license-1.0-explained
     "CC0-1.0",      # https://creativecommons.org/publicdomain/zero/1.0/
     "ISC",          # https://tldrlegal.com/license/-isc-license
-    "LicenseRef-UFL-1.0", # https://tldrlegal.com/license/ubuntu-font-license,-1.0 - no official SPDX, see https://github.com/emilk/egui/issues/2321
     "MIT",          # https://tldrlegal.com/license/mit-license
     "MPL-2.0",      # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11
-    "OFL-1.1",            # https://spdx.org/licenses/OFL-1.1.html
     "OpenSSL",      # https://www.openssl.org/source/license.html
-    "Unicode-DFS-2016",   # https://spdx.org/licenses/Unicode-DFS-2016.html
     "Zlib",         # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
 ]
 

docs/index.html

@@ -33,8 +33,6 @@
             overflow: hidden;
             margin: 0 !important;
             padding: 0 !important;
-            height: 100%;
-            width: 100%;
         }
 
         /* Position canvas in center-top: */
@@ -133,11 +131,7 @@
             console.debug("wasm loaded. starting app…");
 
             // This call installs a bunch of callbacks and then returns:
-            const handle = wasm_bindgen.start("the_canvas_id");
+            wasm_bindgen.start("the_canvas_id");
-
-            // call `handle.stop_web()` to stop
-            // uncomment to quick result
-            // setTimeout(() => {handle.stop_web(); handle.free())}, 2000)
 
             console.debug("app started.");
             document.getElementById("center_text").remove();

docs/multiple_apps.html

@@ -1,200 +0,0 @@
-<!DOCTYPE html>
-<html>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-<!-- Disable zooming: -->
-<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-
-<head>
-    <title>egui – An immediate mode GUI written in Rust</title>
-    <style>
-        html {
-            /* Remove touch delay: */
-            touch-action: manipulation;
-        }
-
-        body {
-            /* Light mode background color for what is not covered by the egui canvas,
-            or where the egui canvas is translucent. */
-            background: #909090;
-            display:flex;
-        }
-
-        .canvas_wrap{
-            /* height: 200px; */
-            width: 400px;
-        }
-
-        @media (prefers-color-scheme: dark) {
-            body {
-                /* Dark mode background color for what is not covered by the egui canvas,
-                or where the egui canvas is translucent. */
-                background: #404040;
-            }
-        }
-
-        /* Allow canvas to fill entire web page: */
-        html,
-        body {
-            overflow: hidden;
-            margin: 0 !important;
-            padding: 0 !important;
-            height: 100%;
-            width: 100%;
-        }
-
-        /* Position canvas in center-top: */
-        canvas {
-            /* margin-right: auto;
-            margin-left: auto; */
-            /* display: block;
-            position: absolute;
-            top: 0%;
-            left: 50%;
-            transform: translate(-50%, 0%); */
-            width:90%;
-            height:90%;
-        }
-
-        .centered {
-            margin-right: auto;
-            margin-left: auto;
-            display: block;
-            position: absolute;
-            top: 50%;
-            left: 50%;
-            transform: translate(-50%, -50%);
-            color: #f0f0f0;
-            font-size: 24px;
-            font-family: Ubuntu-Light, Helvetica, sans-serif;
-            text-align: center;
-        }
-
-        /* ---------------------------------------------- */
-        /* Loading animation from https://loading.io/css/ */
-        .lds-dual-ring {
-            display: inline-block;
-            width: 24px;
-            height: 24px;
-        }
-
-        .lds-dual-ring:after {
-            content: " ";
-            display: block;
-            width: 24px;
-            height: 24px;
-            margin: 0px;
-            border-radius: 50%;
-            border: 3px solid #fff;
-            border-color: #fff transparent #fff transparent;
-            animation: lds-dual-ring 1.2s linear infinite;
-        }
-
-        @keyframes lds-dual-ring {
-            0% {
-                transform: rotate(0deg);
-            }
-
-            100% {
-                transform: rotate(360deg);
-            }
-        }
-    </style>
-</head>
-
-<body>
-    <!-- The WASM code will resize the canvas dynamically -->
-
-    <div>controls</div>
-
-    <button class="stop_one">
-    stop    
-    </button>
-
-    <div class="canvas_wrap one">
-        <canvas id="the_canvas_id_one"></canvas>
-    </div>
-
-    <div  class="canvas_wrap two">
-        <canvas id="the_canvas_id_two"></canvas>
-    </div>
-
-
-
-    <div class="centered" id="center_text">
-        <p style="font-size:16px">
-            Loading…
-        </p>
-        <div class="lds-dual-ring"></div>
-    </div>
-
-    <script>
-        // The `--no-modules`-generated JS from `wasm-bindgen` attempts to use
-        // `WebAssembly.instantiateStreaming` to instantiate the wasm module,
-        // but this doesn't work with `file://` urls. This example is frequently
-        // viewed by simply opening `index.html` in a browser (with a `file://`
-        // url), so it would fail if we were to call this function!
-        //
-        // Work around this for now by deleting the function to ensure that the
-        // `no_modules.js` script doesn't have access to it. You won't need this
-        // hack when deploying over HTTP.
-        delete WebAssembly.instantiateStreaming;
-    </script>
-
-    <!-- this is the JS generated by the `wasm-bindgen` CLI tool -->
-    <script src="egui_demo_app.js"></script>
-
-    <script>
-        // We'll defer our execution until the wasm is ready to go.
-        // Here we tell bindgen the path to the wasm file so it can start
-        // initialization and return to us a promise when it's done.
-        console.debug("loading wasm…");
-        wasm_bindgen("./egui_demo_app_bg.wasm")
-            .then(on_wasm_loaded)
-            .catch(on_wasm_error);
-
-        function on_wasm_loaded() {
-            console.debug("wasm loaded. starting app…");
-
-            // This call installs a bunch of callbacks and then returns:
-
-            wasm_bindgen.init_wasm_hooks()
-
-            const handle_one = wasm_bindgen.start_separate("the_canvas_id_one");
-            const handle_two = wasm_bindgen.start_separate("the_canvas_id_two");
-
-            const button = document.getElementsByClassName("stop_one")[0]
-
-            button.addEventListener("click", ()=>{
-                handle_one.stop_web()
-                handle_one.free()
-            });
-    
-
-            // call `handle.stop_web()` to stop
-            // uncomment to quick result
-            // setTimeout(() => {handle.stop_web()}, 2000)
-
-            console.debug("app started.");
-            document.getElementById("center_text").remove();
-        }
-
-        function on_wasm_error(error) {
-            console.error("Failed to start: " + error);
-            document.getElementById("center_text").innerHTML = `
-                <p>
-                    An error occurred during loading:
-                </p>
-                <p style="font-family:Courier New">
-                    ${error}
-                </p>
-                <p style="font-size:14px">
-                    Make sure you use a modern browser with WebGL and WASM enabled.
-                </p>`;
-        }
-    </script>
-</body>
-
-</html>
-
-<!-- Powered by egui: https://github.com/emilk/egui/ -->

eframe/CHANGELOG.md

@@ -0,0 +1,150 @@
+# Changelog for eframe
+All notable changes to the `eframe` crate.
+
+NOTE: [`egui-winit`](../egui-winit/CHANGELOG.md), [`egui_glium`](../egui_glium/CHANGELOG.md), and [`egui_glow`](../egui_glow/CHANGELOG.md) have their own changelogs!
+
+
+## Unreleased
+* `egui_glow`: remove calls to `gl.get_error` in release builds to speed up rendering ([#1583](https://github.com/emilk/egui/pull/1583)).
+* Add `wgpu` rendering backed ([#1564](https://github.com/emilk/egui/pull/1564)):
+  * Add features "wgpu" and "glow"
+  * Add `NativeOptions::renderer` to switch between the rendering backends
+* Fix clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
+* Allow running on native without hardware accelerated rendering. Change with `NativeOptions::hardware_acceleration` ([#1681]([#1693](https://github.com/emilk/egui/pull/1693)).
+* `dark-light` (dark mode detection) is now enabled by default on Mac and Windows ([#1726](https://github.com/emilk/egui/pull/1726)).
+* Add `NativeOptions::follow_system_theme` and `NativeOptions::default_theme` ([#1726](https://github.com/emilk/egui/pull/1726)).
+
+
+## 0.18.0 - 2022-04-30
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Removed `eframe::epi` - everything is now in `eframe` (`eframe::App`, `eframe::Frame` etc) ([#1545](https://github.com/emilk/egui/pull/1545)).
+* Removed `Frame::request_repaint` - just call `egui::Context::request_repaint` for the same effect ([#1366](https://github.com/emilk/egui/pull/1366)).
+* Changed app creation/setup ([#1363](https://github.com/emilk/egui/pull/1363)):
+  * Removed `App::setup` and `App::name`.
+  * Provide `CreationContext` when creating app with egui context, storage, integration info and glow context.
+  * Change interface of `run_native` and `start_web`.
+* Added `Frame::storage()` and `Frame::storage_mut()` ([#1418](https://github.com/emilk/egui/pull/1418)).
+  * You can now load/save state in `App::update`
+  * Changed `App::update` to take `&mut Frame` instead of `&Frame`.
+  * `Frame` is no longer `Clone` or `Sync`.
+* Add `glow` (OpenGL) context to `Frame` ([#1425](https://github.com/emilk/egui/pull/1425)).
+
+#### Desktop/Native:
+* Remove the `egui_glium` feature. `eframe` will now always use `egui_glow` as the native backend ([#1357](https://github.com/emilk/egui/pull/1357)).
+* Change default for `NativeOptions::drag_and_drop_support` to `true` ([#1329](https://github.com/emilk/egui/pull/1329)).
+* Added new `NativeOptions`: `vsync`, `multisampling`, `depth_buffer`, `stencil_buffer`.
+* `dark-light` (dark mode detection) is now an opt-in feature ([#1437](https://github.com/emilk/egui/pull/1437)).
+* Fixed potential scale bug when DPI scaling changes (e.g. when dragging a  window between different displays) ([#1441](https://github.com/emilk/egui/pull/1441)).
+* Added new feature `puffin` to add [`puffin profiler`](https://github.com/EmbarkStudios/puffin) scopes ([#1483](https://github.com/emilk/egui/pull/1483)).
+* Moved app persistence to a background thread, allowing for smoother frame rates (on native).
+* Added `Frame::set_window_pos` ([#1505](https://github.com/emilk/egui/pull/1505)).
+
+#### Web:
+* Use full browser width by default ([#1378](https://github.com/emilk/egui/pull/1378)).
+* egui code will no longer be called after panic ([#1306](https://github.com/emilk/egui/pull/1306)).
+
+
+## 0.17.0 - 2022-02-22
+* Removed `Frame::alloc_texture`. Use `egui::Context::load_texture` instead ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Log using the `tracing` crate. Log to stdout by adding `tracing_subscriber::fmt::init();` to your `main` ([#1192](https://github.com/emilk/egui/pull/1192)).
+
+#### Desktop/Native:
+* The default native backend is now `egui_glow` (instead of `egui_glium`) ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+* Fix horizontal scrolling direction on Linux.
+* Added `App::on_exit_event` ([#1038](https://github.com/emilk/egui/pull/1038))
+* Added `NativeOptions::initial_window_pos`.
+* Fixed `enable_drag` for Windows OS ([#1108](https://github.com/emilk/egui/pull/1108)).
+
+#### Web:
+* The default web painter is now `egui_glow` (instead of WebGL) ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Fixed glow failure on Chromium ([#1092](https://github.com/emilk/egui/pull/1092)).
+* Updated `eframe::IntegrationInfo::web_location_hash` on `hashchange` event ([#1140](https://github.com/emilk/egui/pull/1140)).
+* Expose all parts of the location/url in `frame.info().web_info` ([#1258](https://github.com/emilk/egui/pull/1258)).
+
+
+## 0.16.0 - 2021-12-29
+* `Frame` can now be cloned, saved, and passed to background threads ([#999](https://github.com/emilk/egui/pull/999)).
+* Added `Frame::request_repaint` to replace `repaint_signal` ([#999](https://github.com/emilk/egui/pull/999)).
+* Added `Frame::alloc_texture/free_texture` to replace `tex_allocator` ([#999](https://github.com/emilk/egui/pull/999)).
+
+#### Web:
+* Fixed [dark rendering in WebKitGTK](https://github.com/emilk/egui/issues/794) ([#888](https://github.com/emilk/egui/pull/888/)).
+* Added feature `glow` to switch to a [`glow`](https://github.com/grovesNL/glow) based painter ([#868](https://github.com/emilk/egui/pull/868)).
+
+
+## 0.15.0 - 2021-10-24
+* `Frame` now provides `set_window_title` to set window title dynamically
+* `Frame` now provides `set_decorations` to set whether to show window decorations.
+* Remove "http" feature (use https://github.com/emilk/ehttp instead!).
+* Add `App::persist_native_window` and `App::persist_egui_memory` to control what gets persisted.
+
+#### Desktop/Native:
+* Increase native scroll speed.
+* Add new backend `egui_glow` as an alternative to `egui_glium`. Enable with `default-features = false, features = ["default_fonts", "egui_glow"]`.
+
+#### Web:
+* Implement `eframe::NativeTexture` trait for the WebGL painter.
+* Deprecate `Painter::register_webgl_texture.
+* Fix multiline paste.
+* Fix painting with non-opaque backgrounds.
+* Improve text input on mobile and for IME.
+
+
+## 0.14.0 - 2021-08-24
+* Add dragging and dropping files into egui.
+* Improve http fetch API.
+* `run_native` now returns when the app is closed.
+* Web: Made text thicker and less pixelated.
+
+
+## 0.13.1 - 2021-06-24
+* Fix `http` feature flag and docs
+
+
+## 0.13.0 - 2021-06-24
+* `App::setup` now takes a `Frame` and `Storage` by argument.
+* `App::load` has been removed. Implement `App::setup` instead.
+* Web: Default to light visuals unless the system reports a preference for dark mode.
+* Web: Improve alpha blending, making fonts look much better (especially in light mode)
+* Web: Fix double-paste bug
+
+
+## 0.12.0 - 2021-05-10
+* Moved options out of `trait App` into new `NativeOptions`.
+* Add option for `always_on_top`.
+* Web: Scroll faster when scrolling with mouse wheel.
+
+
+## 0.11.0 - 2021-04-05
+* You can now turn your window transparent with the `App::transparent` option.
+* You can now disable window decorations with the `App::decorated` option.
+* Web: [Fix mobile and IME text input](https://github.com/emilk/egui/pull/253)
+* Web: Hold down a modifier key when clicking a link to open it in a new tab.
+
+Contributors: [n2](https://github.com/n2)
+
+
+## 0.10.0 - 2021-02-28
+* [You can now set your own app icons](https://github.com/emilk/egui/pull/193).
+* You can control the initial size of the native window with `App::initial_window_size`.
+* You can control the maximum egui web canvas size with `App::max_size_points`.
+* `Frame::tex_allocator()` no longer returns an `Option` (there is always a texture allocator).
+
+
+## 0.9.0 - 2021-02-07
+* [Add support for HTTP body](https://github.com/emilk/egui/pull/139).
+* Web: Right-clicks will no longer open browser context menu.
+* Web: Fix a bug where one couldn't select items in a combo box on a touch screen.
+
+
+## 0.8.0 - 2021-01-17
+* Simplify `TextureAllocator` interface.
+* WebGL2 is now supported, with improved texture sampler. WebGL1 will be used as a fallback.
+* Web: Slightly improved alpha-blending (work-around for non-existing linear-space blending).
+* Web: Call `prevent_default` for arrow keys when entering text
+
+
+## 0.7.0 - 2021-01-04
+* Initial release of `eframe`

eframe/Cargo.toml

@@ -0,0 +1,146 @@
+[package]
+name = "eframe"
+version = "0.18.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "egui framework - write GUI apps that compiles to web and/or natively"
+edition = "2021"
+rust-version = "1.60"
+homepage = "https://github.com/emilk/egui/tree/master/eframe"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/eframe"
+categories = ["gui", "game-development"]
+keywords = ["egui", "gui", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = ["dark-light", "default_fonts", "glow"]
+
+## Detect dark mode system preference using [`dark-light`](https://docs.rs/dark-light).
+##
+## See also [`NativeOptions::follow_system_theme`] and [`NativeOptions::default_theme`].
+dark-light = ["dep:dark-light"]
+
+## If set, egui will use `include_bytes!` to bundle some fonts.
+## If you plan on specifying your own fonts you may disable this feature.
+default_fonts = ["egui/default_fonts"]
+
+## Use [`glow`](https://github.com/grovesNL/glow) for painting, via [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow).
+glow = ["dep:glow", "egui_glow"]
+
+## Enable saving app state to disk.
+persistence = [
+  "directories-next",
+  "egui-winit/serde",
+  "egui/persistence",
+  "ron",
+  "serde",
+]
+
+## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
+##
+## Only enabled on native, because of the low resolution (1ms) of time keeping in browsers.
+## `eframe` will call `puffin::GlobalProfiler::lock().new_frame()` for you
+puffin = ["dep:puffin", "egui_glow/puffin"]
+
+## Enable screen reader support (requires `ctx.options().screen_reader = true;`)
+screen_reader = [
+  "egui-winit/screen_reader",
+  "tts",
+]
+
+## Use [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui_wgpu`](https://github.com/emilk/egui/tree/master/egui_wgpu)).
+## This overrides the `glow` feature.
+wgpu = ["dep:wgpu", "egui-wgpu"]
+
+
+[dependencies]
+egui = { version = "0.18.0", path = "../egui", default-features = false, features = [
+  "bytemuck",
+  "tracing",
+] }
+tracing = "0.1"
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+egui_glow = { version = "0.18.0", path = "../egui_glow", optional = true, default-features = false }
+egui-wgpu = { version = "0.18.0", path = "../egui-wgpu", optional = true, features = ["winit"] }
+glow = { version = "0.11", optional = true }
+ron = { version = "0.7", optional = true }
+serde = { version = "1", optional = true, features = ["derive"] }
+wgpu = { version = "0.13", optional = true }
+
+# -------------------------------------------
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+dark-light = { version = "0.2.1", optional = true }
+egui-winit = { version = "0.18.0", path = "../egui-winit", default-features = false, features = ["clipboard", "links"] }
+glutin = { version = "0.28.0" }
+winit = "0.26.1"
+
+# optional native:
+puffin = { version = "0.13", optional = true }
+directories-next = { version = "2", optional = true }
+
+# -------------------------------------------
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+bytemuck = "1.7"
+js-sys = "0.3"
+percent-encoding = "2.1"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3.52", features = [
+  "BinaryType",
+  "Blob",
+  "Clipboard",
+  "ClipboardEvent",
+  "CompositionEvent",
+  "console",
+  "CssStyleDeclaration",
+  "DataTransfer",
+  "DataTransferItem",
+  "DataTransferItemList",
+  "Document",
+  "DomRect",
+  "DragEvent",
+  "Element",
+  "Event",
+  "EventListener",
+  "EventTarget",
+  "ExtSRgb",
+  "File",
+  "FileList",
+  "FocusEvent",
+  "HtmlCanvasElement",
+  "HtmlElement",
+  "HtmlInputElement",
+  "InputEvent",
+  "KeyboardEvent",
+  "Location",
+  "MediaQueryList",
+  "MouseEvent",
+  "Navigator",
+  "Performance",
+  "Storage",
+  "Touch",
+  "TouchEvent",
+  "TouchList",
+  "WebGl2RenderingContext",
+  "WebglDebugRendererInfo",
+  "WebGlRenderingContext",
+  "WheelEvent",
+  "Window",
+] }
+
+# optional
+# feature screen_reader
+tts = { version = "0.20", optional = true } # Can't use 0.22 due to compilation problems on linux: https://github.com/emilk/egui/runs/7170127089?check_suite_focus=true#step:5:713

eframe/README.md

@@ -17,24 +17,22 @@ For how to use `egui`, see [the egui docs](https://docs.rs/egui).
 
 ---
 
-`eframe` uses [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) for rendering, and on native it uses [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit).
+`eframe` uses [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) for rendering, and on native it uses [`egui-winit`](https://github.com/emilk/egui/tree/master/egui-winit).
 
 To use on Linux, first run:
 
 ```
-sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev
+sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libspeechd-dev libxkbcommon-dev libssl-dev
 ```
 
 You need to either use `edition = "2021"`, or set `resolver = "2"` in the `[workspace]` section of your to-level `Cargo.toml`. See [this link](https://doc.rust-lang.org/edition-guide/rust-2021/default-cargo-resolver.html) for more info.
 
-You can opt-in to the using [`egui_wgpu`](https://github.com/emilk/egui/tree/master/crates/egui_wgpu) for rendering by enabling the `wgpu` feature and setting `NativeOptions::renderer` to `Renderer::Wgpu`.
+You can opt-in to the using [`egui_wgpu`](https://github.com/emilk/egui/tree/master/egui_wgpu) for rendering by enabling the `wgpu` feature and setting `NativeOptions::renderer` to `Renderer::Wgpu`.
 
 
 ## Alternatives
 `eframe` is not the only way to write an app using `egui`! You can also try [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad), [`bevy_egui`](https://github.com/mvlabat/bevy_egui), [`egui_sdl2_gl`](https://github.com/ArjunNair/egui_sdl2_gl), and others.
 
-You can also use `egui_glow` and [`winit`](https://github.com/rust-windowing/winit) to build your own app as demonstrated in <https://github.com/emilk/egui/blob/master/crates/egui_glow/examples/pure_glow.rs>.
-
 
 ## Problems with running egui on the web
 `eframe` uses WebGL (via [`glow`](https://crates.io/crates/glow)) and WASM, and almost nothing else from the web tech stack. This has some benefits, but also produces some challenges and serious downsides.
@@ -45,6 +43,7 @@ You can also use `egui_glow` and [`winit`](https://github.com/rust-windowing/win
 * Mobile text editing is not as good as for a normal web app.
 * Accessibility: There is an experimental screen reader for `eframe`, but it has to be enabled explicitly. There is no JS function to ask "Does the user want a screen reader?" (and there should probably not be such a function, due to user tracking/integrity concerns).
 * No integration with browser settings for colors and fonts.
+* On Linux and Mac, Firefox will copy the WebGL render target from GPU, to CPU and then back again (https://bugzilla.mozilla.org/show_bug.cgi?id=1010527#c0), slowing down egui.
 
 In many ways, `eframe` is trying to make the browser do something it wasn't designed to do (though there are many things browser vendors could do to improve how well libraries like egui work).
 

eframe/src/epi.rs

@@ -6,25 +6,6 @@
 
 #![warn(missing_docs)] // Let's keep `epi` well-documented.
 
-#[cfg(target_arch = "wasm32")]
-use std::any::Any;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
-pub use crate::native::run::UserEvent;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
-pub use winit::event_loop::EventLoopBuilder;
-
-/// Hook into the building of an event loop before it is run
-///
-/// You can configure any platform specific details required on top of the default configuration
-/// done by `EFrame`.
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
-pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<UserEvent>)>;
-
 /// This is how your app is created.
 ///
 /// You can use the [`CreationContext`] to setup egui, restore state, setup OpenGL things, etc.
@@ -46,23 +27,18 @@ pub struct CreationContext<'s> {
 
     /// The [`glow::Context`] allows you to initialize OpenGL resources (e.g. shaders) that
     /// you might want to use later from a [`egui::PaintCallback`].
-    ///
-    /// Only available when compiling with the `glow` feature and using [`Renderer::Glow`].
     #[cfg(feature = "glow")]
     pub gl: Option<std::sync::Arc<glow::Context>>,
 
-    /// The underlying WGPU render state.
+    /// Can be used to manage GPU resources for custom rendering with WGPU using
-    ///
+    /// [`egui::PaintCallback`]s.
-    /// Only available when compiling with the `wgpu` feature and using [`Renderer::Wgpu`].
-    ///
-    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
     #[cfg(feature = "wgpu")]
-    pub wgpu_render_state: Option<egui_wgpu::RenderState>,
+    pub render_state: Option<egui_wgpu::RenderState>,
 }
 
 // ----------------------------------------------------------------------------
 
-/// Implement this trait to write apps that can be compiled for both web/wasm and desktop/native using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+/// Implement this trait to write apps that can be compiled for both web/wasm and desktop/native using [`eframe`](https://github.com/emilk/egui/tree/master/eframe).
 pub trait App {
     /// Called each time the UI needs repainting, which may be many times per second.
     ///
@@ -73,26 +49,6 @@ pub trait App {
     /// To force a repaint, call [`egui::Context::request_repaint`] at any time (e.g. from another thread).
     fn update(&mut self, ctx: &egui::Context, frame: &mut Frame);
 
-    /// Get a handle to the app.
-    ///
-    /// Can be used from web to interact or other external context.
-    ///
-    /// You need to implement this if you want to be able to access the application from JS using [`crate::web::backend::AppRunner`].
-    ///
-    /// This is needed because downcasting `Box<dyn App>` -> `Box<dyn Any>` to get &`ConcreteApp` is not simple in current rust.
-    ///
-    /// Just copy-paste this as your implementation:
-    /// ```ignore
-    /// #[cfg(target_arch = "wasm32")]
-    /// fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
-    ///     Some(&mut *self)
-    /// }
-    /// ```
-    #[cfg(target_arch = "wasm32")]
-    fn as_any_mut(&mut self) -> Option<&mut dyn Any> {
-        None
-    }
-
     /// Called on shutdown, and perhaps at regular intervals. Allows you to save state.
     ///
     /// Only called when the "persistence" feature is enabled.
@@ -106,25 +62,21 @@ pub trait App {
     /// where `APPNAME` is what is given to `eframe::run_native`.
     fn save(&mut self, _storage: &mut dyn Storage) {}
 
-    /// Called when the user attempts to close the desktop window and/or quit the application.
+    /// Called before an exit that can be aborted.
-    ///
+    /// By returning `false` the exit will be aborted. To continue the exit return `true`.
-    /// By returning `false` the closing will be aborted. To continue the closing return `true`.
     ///
     /// A scenario where this method will be run is after pressing the close button on a native
     /// window, which allows you to ask the user whether they want to do something before exiting.
     /// See the example at <https://github.com/emilk/egui/blob/master/examples/confirm_exit/> for practical usage.
     ///
     /// It will _not_ be called on the web or when the window is forcefully closed.
-    #[cfg(not(target_arch = "wasm32"))]
+    fn on_exit_event(&mut self) -> bool {
-    #[doc(alias = "exit")]
-    #[doc(alias = "quit")]
-    fn on_close_event(&mut self) -> bool {
         true
     }
 
     /// Called once on shutdown, after [`Self::save`].
     ///
-    /// If you need to abort an exit use [`Self::on_close_event`].
+    /// If you need to abort an exit use [`Self::on_exit_event`].
     ///
     /// To get a [`glow`] context you need to compile with the `glow` feature flag,
     /// and run eframe with the glow backend.
@@ -133,7 +85,7 @@ pub trait App {
 
     /// Called once on shutdown, after [`Self::save`].
     ///
-    /// If you need to abort an exit use [`Self::on_close_event`].
+    /// If you need to abort an exit use [`Self::on_exit_event`].
     #[cfg(not(feature = "glow"))]
     fn on_exit(&mut self) {}
 
@@ -148,25 +100,20 @@ pub trait App {
     /// The size limit of the web app canvas.
     ///
     /// By default the max size is [`egui::Vec2::INFINITY`], i.e. unlimited.
+    ///
+    /// A large canvas can lead to bad frame rates on some older browsers on some platforms
+    /// (see <https://bugzilla.mozilla.org/show_bug.cgi?id=1010527#c0>).
     fn max_size_points(&self) -> egui::Vec2 {
         egui::Vec2::INFINITY
     }
 
-    /// Background color values for the app, e.g. what is sent to `gl.clearColor`.
+    /// Background color for the app, e.g. what is sent to `gl.clearColor`.
-    ///
     /// This is the background of your windows if you don't set a central panel.
-    ///
+    fn clear_color(&self, _visuals: &egui::Visuals) -> egui::Rgba {
-    /// ATTENTION:
-    /// Since these float values go to the render as-is, any color space conversion as done
-    /// e.g. by converting from [`egui::Color32`] to [`egui::Rgba`] may cause incorrect results.
-    /// egui recommends that rendering backends use a normal "gamma-space" (non-sRGB-aware) blending,
-    ///  which means the values you return here should also be in `sRGB` gamma-space in the 0-1 range.
-    /// You can use [`egui::Color32::to_normalized_gamma_f32`] for this.
-    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
         // NOTE: a bright gray makes the shadows of the windows look weird.
         // We use a bit of transparency so that if the user switches on the
         // `transparent()` option they get immediate results.
-        egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32()
+        egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).into()
 
         // _visuals.window_fill() would also be a natural choice
     }
@@ -184,7 +131,7 @@ pub trait App {
     }
 
     /// If `true` a warm-up call to [`Self::update`] will be issued where
-    /// `ctx.memory(|mem| mem.everything_is_visible())` will be set to `true`.
+    /// `ctx.memory().everything_is_visible()` will be set to `true`.
     ///
     /// This can help pre-caching resources loaded by different parts of the UI, preventing stutter later on.
     ///
@@ -221,8 +168,9 @@ pub enum HardwareAcceleration {
 ///
 /// Only a single native window is currently supported.
 #[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone)]
 pub struct NativeOptions {
-    /// Sets whether or not the window will always be on top of other windows at initialization.
+    /// Sets whether or not the window will always be on top of other windows.
     pub always_on_top: bool,
 
     /// Show window in maximized mode
@@ -232,19 +180,6 @@ pub struct NativeOptions {
     /// If false it will be difficult to move and resize the app.
     pub decorated: bool,
 
-    /// Start in (borderless) fullscreen?
-    ///
-    /// Default: `false`.
-    pub fullscreen: bool,
-
-    /// On Mac: the window doesn't have a titlebar, but floating window buttons.
-    ///
-    /// See [winit's documentation][with_fullsize_content_view] for information on Mac-specific options.
-    ///
-    /// [with_fullsize_content_view]: https://docs.rs/winit/latest/x86_64-apple-darwin/winit/platform/macos/trait.WindowBuilderExtMacOS.html#tymethod.with_fullsize_content_view
-    #[cfg(target_os = "macos")]
-    pub fullsize_content: bool,
-
     /// On Windows: enable drag and drop support. Drag and drop can
     /// not be disabled on other platforms.
     ///
@@ -255,9 +190,6 @@ pub struct NativeOptions {
     pub drag_and_drop_support: bool,
 
     /// The application icon, e.g. in the Windows task bar etc.
-    ///
-    /// This doesn't work on Mac and on Wayland.
-    /// See <https://docs.rs/winit/latest/winit/window/struct.Window.html#method.set_window_icon> for more.
     pub icon_data: Option<IconData>,
 
     /// The initial (inner) position of the native window in points (logical pixels).
@@ -266,10 +198,10 @@ pub struct NativeOptions {
     /// The initial inner size of the native window in points (logical pixels).
     pub initial_window_size: Option<egui::Vec2>,
 
-    /// The minimum inner window size in points (logical pixels).
+    /// The minimum inner window size
     pub min_window_size: Option<egui::Vec2>,
 
-    /// The maximum inner window size in points (logical pixels).
+    /// The maximum inner window size
     pub max_window_size: Option<egui::Vec2>,
 
     /// Should the app window be resizable?
@@ -280,10 +212,6 @@ pub struct NativeOptions {
     /// You should avoid having a [`egui::CentralPanel`], or make sure its frame is also transparent.
     pub transparent: bool,
 
-    /// On desktop: mouse clicks pass through the window, used for non-interactable overlays
-    /// Generally you would use this in conjunction with always_on_top
-    pub mouse_passthrough: bool,
-
     /// Turn on vertical syncing, limiting the FPS to the display refresh rate.
     ///
     /// The default is `true`.
@@ -303,10 +231,6 @@ pub struct NativeOptions {
     /// Sets the number of bits in the depth buffer.
     ///
     /// `egui` doesn't need the depth buffer, so the default value is 0.
-    ///
-    /// On `wgpu` backends, due to limited depth texture format options, this
-    /// will be interpreted as a boolean (non-zero = true) for whether or not
-    /// specifically a `Depth32Float` buffer is used.
     pub depth_buffer: u8,
 
     /// Sets the number of bits in the stencil buffer.
@@ -314,16 +238,15 @@ pub struct NativeOptions {
     /// `egui` doesn't need the stencil buffer, so the default value is 0.
     pub stencil_buffer: u8,
 
-    /// Specify whether or not hardware acceleration is preferred, required, or not.
+    /// Specify wether or not hardware acceleration is preferred, required, or not.
     ///
     /// Default: [`HardwareAcceleration::Preferred`].
     pub hardware_acceleration: HardwareAcceleration,
 
     /// What rendering backend to use.
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
     pub renderer: Renderer,
 
-    /// Only used if the `dark-light` feature is enabled:
+    /// If the `dark-light` feature is enabled:
     ///
     /// Try to detect and follow the system preferred setting for dark vs light mode.
     ///
@@ -336,66 +259,8 @@ pub struct NativeOptions {
     /// Which theme to use in case [`Self::follow_system_theme`] is `false`
     /// or the `dark-light` feature is disabled.
     ///
-    /// Default: [`Theme::Dark`].
+    /// Default: `Theme::Dark`.
     pub default_theme: Theme,
-
-    /// This controls what happens when you close the main eframe window.
-    ///
-    /// If `true`, execution will continue after the eframe window is closed.
-    /// If `false`, the app will close once the eframe window is closed.
-    ///
-    /// This is `true` by default, and the `false` option is only there
-    /// so we can revert if we find any bugs.
-    ///
-    /// This feature was introduced in <https://github.com/emilk/egui/pull/1889>.
-    ///
-    /// When `true`, [`winit::platform::run_return::EventLoopExtRunReturn::run_return`] is used.
-    /// When `false`, [`winit::event_loop::EventLoop::run`] is used.
-    pub run_and_return: bool,
-
-    /// Hook into the building of an event loop before it is run.
-    ///
-    /// Specify a callback here in case you need to make platform specific changes to the
-    /// event loop before it is run.
-    ///
-    /// Note: A [`NativeOptions`] clone will not include any `event_loop_builder` hook.
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
-    pub event_loop_builder: Option<EventLoopBuilderHook>,
-
-    #[cfg(feature = "glow")]
-    /// Needed for cross compiling for VirtualBox VMSVGA driver with OpenGL ES 2.0 and OpenGL 2.1 which doesn't support SRGB texture.
-    /// See <https://github.com/emilk/egui/pull/1993>.
-    ///
-    /// For OpenGL ES 2.0: set this to [`egui_glow::ShaderVersion::Es100`] to solve blank texture problem (by using the "fallback shader").
-    pub shader_version: Option<egui_glow::ShaderVersion>,
-
-    /// On desktop: make the window position to be centered at initialization.
-    ///
-    /// Platform specific:
-    ///
-    /// Wayland desktop currently not supported.
-    pub centered: bool,
-
-    /// Configures wgpu instance/device/adapter/surface creation and renderloop.
-    #[cfg(feature = "wgpu")]
-    pub wgpu_options: egui_wgpu::WgpuConfiguration,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl Clone for NativeOptions {
-    fn clone(&self) -> Self {
-        Self {
-            icon_data: self.icon_data.clone(),
-
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
-            event_loop_builder: None, // Skip any builder callbacks if cloning
-
-            #[cfg(feature = "wgpu")]
-            wgpu_options: self.wgpu_options.clone(),
-
-            ..*self
-        }
-    }
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -405,11 +270,6 @@ impl Default for NativeOptions {
             always_on_top: false,
             maximized: false,
             decorated: true,
-            fullscreen: false,
-
-            #[cfg(target_os = "macos")]
-            fullsize_content: false,
-
             drag_and_drop_support: true,
             icon_data: None,
             initial_window_pos: None,
@@ -418,30 +278,14 @@ impl Default for NativeOptions {
             max_window_size: None,
             resizable: true,
             transparent: false,
-            mouse_passthrough: false,
             vsync: true,
             multisampling: 0,
             depth_buffer: 0,
             stencil_buffer: 0,
             hardware_acceleration: HardwareAcceleration::Preferred,
-
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
             renderer: Renderer::default(),
-
             follow_system_theme: cfg!(target_os = "macos") || cfg!(target_os = "windows"),
             default_theme: Theme::Dark,
-            run_and_return: true,
-
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
-            event_loop_builder: None,
-
-            #[cfg(feature = "glow")]
-            shader_version: None,
-
-            centered: false,
-
-            #[cfg(feature = "wgpu")]
-            wgpu_options: egui_wgpu::WgpuConfiguration::default(),
         }
     }
 }
@@ -456,7 +300,6 @@ impl NativeOptions {
             match dark_light::detect() {
                 dark_light::Mode::Dark => Some(Theme::Dark),
                 dark_light::Mode::Light => Some(Theme::Light),
-                dark_light::Mode::Default => None,
             }
         } else {
             None
@@ -487,16 +330,6 @@ pub struct WebOptions {
     ///
     /// Default: `Theme::Dark`.
     pub default_theme: Theme,
-
-    /// Which version of WebGl context to select
-    ///
-    /// Default: [`WebGlContextOption::BestFirst`].
-    #[cfg(feature = "glow")]
-    pub webgl_context_option: WebGlContextOption,
-
-    /// Configures wgpu instance/device/adapter/surface creation and renderloop.
-    #[cfg(feature = "wgpu")]
-    pub wgpu_options: egui_wgpu::WgpuConfiguration,
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -505,26 +338,6 @@ impl Default for WebOptions {
         Self {
             follow_system_theme: true,
             default_theme: Theme::Dark,
-
-            #[cfg(feature = "glow")]
-            webgl_context_option: WebGlContextOption::BestFirst,
-
-            #[cfg(feature = "wgpu")]
-            wgpu_options: egui_wgpu::WgpuConfiguration {
-                // WebGPU is not stable enough yet, use WebGL emulation
-                backends: wgpu::Backends::GL,
-                device_descriptor: wgpu::DeviceDescriptor {
-                    label: Some("egui wgpu device"),
-                    features: wgpu::Features::default(),
-                    limits: wgpu::Limits {
-                        // When using a depth buffer, we have to be able to create a texture
-                        // large enough for the entire surface, and we want to support 4k+ displays.
-                        max_texture_dimension_2d: 8192,
-                        ..wgpu::Limits::downlevel_webgl2_defaults()
-                    },
-                },
-                ..Default::default()
-            },
         }
     }
 }
@@ -537,7 +350,6 @@ impl Default for WebOptions {
 pub enum Theme {
     /// Dark mode: light text on a dark background.
     Dark,
-
     /// Light mode: dark text on a light background.
     Light,
 }
@@ -556,29 +368,9 @@ impl Theme {
 
 // ----------------------------------------------------------------------------
 
-/// WebGL Context options
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub enum WebGlContextOption {
-    /// Force Use WebGL1.
-    WebGl1,
-
-    /// Force use WebGL2.
-    WebGl2,
-
-    /// Use WebGl2 first.
-    BestFirst,
-
-    /// Use WebGl1 first
-    CompatibilityFirst,
-}
-
-// ----------------------------------------------------------------------------
-
 /// What rendering backend to use.
 ///
 /// You need to enable the "glow" and "wgpu" features to have a choice.
-#[cfg(any(feature = "glow", feature = "wgpu"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
@@ -592,7 +384,6 @@ pub enum Renderer {
     Wgpu,
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
 impl Default for Renderer {
     fn default() -> Self {
         #[cfg(feature = "glow")]
@@ -608,7 +399,6 @@ impl Default for Renderer {
     }
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
 impl std::fmt::Display for Renderer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -621,7 +411,6 @@ impl std::fmt::Display for Renderer {
     }
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
 impl std::str::FromStr for Renderer {
     type Err = String;
 
@@ -659,30 +448,32 @@ pub struct IconData {
 /// allocate textures, and change settings (e.g. window size).
 pub struct Frame {
     /// Information about the integration.
-    pub(crate) info: IntegrationInfo,
+    #[doc(hidden)]
+    pub info: IntegrationInfo,
 
     /// Where the app can issue commands back to the integration.
-    pub(crate) output: backend::AppOutput,
+    #[doc(hidden)]
+    pub output: backend::AppOutput,
 
     /// A place where you can store custom data in a way that persists when you restart the app.
-    pub(crate) storage: Option<Box<dyn Storage>>,
+    #[doc(hidden)]
+    pub storage: Option<Box<dyn Storage>>,
 
     /// A reference to the underlying [`glow`] (OpenGL) context.
     #[cfg(feature = "glow")]
-    pub(crate) gl: Option<std::sync::Arc<glow::Context>>,
+    #[doc(hidden)]
+    pub gl: Option<std::sync::Arc<glow::Context>>,
 
-    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
+    /// Can be used to manage GPU resources for custom rendering with WGPU using
+    /// [`egui::PaintCallback`]s.
     #[cfg(feature = "wgpu")]
-    pub(crate) wgpu_render_state: Option<egui_wgpu::RenderState>,
+    pub render_state: Option<egui_wgpu::RenderState>,
 }
 
 impl Frame {
     /// True if you are in a web environment.
-    ///
-    /// Equivalent to `cfg!(target_arch = "wasm32")`
-    #[allow(clippy::unused_self)]
     pub fn is_web(&self) -> bool {
-        cfg!(target_arch = "wasm32")
+        self.info.web_info.is_some()
     }
 
     /// Information about the integration.
@@ -711,177 +502,75 @@ impl Frame {
     /// ([`egui`] only collects [`egui::Shape`]s and then eframe paints them all in one go later on).
     ///
     /// To get a [`glow`] context you need to compile with the `glow` feature flag,
-    /// and run eframe using [`Renderer::Glow`].
+    /// and run eframe with the glow backend.
     #[cfg(feature = "glow")]
     pub fn gl(&self) -> Option<&std::sync::Arc<glow::Context>> {
         self.gl.as_ref()
     }
 
-    /// The underlying WGPU render state.
+    /// Signal the app to stop/exit/quit the app (only works for native apps, not web apps).
-    ///
+    /// The framework will not quit immediately, but at the end of the this frame.
-    /// Only available when compiling with the `wgpu` feature and using [`Renderer::Wgpu`].
-    ///
-    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
-    #[cfg(feature = "wgpu")]
-    pub fn wgpu_render_state(&self) -> Option<&egui_wgpu::RenderState> {
-        self.wgpu_render_state.as_ref()
-    }
-
-    /// Tell `eframe` to close the desktop window.
-    ///
-    /// The window will not close immediately, but at the end of the this frame.
-    ///
-    /// Calling this will likely result in the app quitting, unless
-    /// you have more code after the call to [`crate::run_native`].
-    #[cfg(not(target_arch = "wasm32"))]
-    #[doc(alias = "exit")]
-    #[doc(alias = "quit")]
-    pub fn close(&mut self) {
-        tracing::debug!("eframe::Frame::close called");
-        self.output.close = true;
-    }
-
-    /// Minimize or unminimize window. (native only)
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_minimized(&mut self, minimized: bool) {
-        self.output.minimized = Some(minimized);
-    }
-
-    /// Maximize or unmaximize window. (native only)
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_maximized(&mut self, maximized: bool) {
-        self.output.maximized = Some(maximized);
-    }
-
-    /// Tell `eframe` to close the desktop window.
-    #[cfg(not(target_arch = "wasm32"))]
-    #[deprecated = "Renamed `close`"]
     pub fn quit(&mut self) {
-        self.close();
+        self.output.quit = true;
     }
 
     /// Set the desired inner size of the window (in egui points).
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn set_window_size(&mut self, size: egui::Vec2) {
         self.output.window_size = Some(size);
-        self.info.window_info.size = size; // so that subsequent calls see the updated value
     }
 
     /// Set the desired title of the window.
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn set_window_title(&mut self, title: &str) {
         self.output.window_title = Some(title.to_owned());
     }
 
     /// Set whether to show window decorations (i.e. a frame around you app).
-    ///
     /// If false it will be difficult to move and resize the app.
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn set_decorations(&mut self, decorated: bool) {
         self.output.decorated = Some(decorated);
     }
 
-    /// Turn borderless fullscreen on/off (native only).
+    /// set the position of the outer window
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_fullscreen(&mut self, fullscreen: bool) {
-        self.output.fullscreen = Some(fullscreen);
-        self.info.window_info.fullscreen = fullscreen; // so that subsequent calls see the updated value
-    }
-
-    /// set the position of the outer window.
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn set_window_pos(&mut self, pos: egui::Pos2) {
         self.output.window_pos = Some(pos);
-        self.info.window_info.position = Some(pos); // so that subsequent calls see the updated value
     }
 
     /// When called, the native window will follow the
     /// movement of the cursor while the primary mouse button is down.
     ///
     /// Does not work on the web.
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn drag_window(&mut self) {
         self.output.drag_window = true;
     }
 
-    /// Set the visibility of the window.
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_visible(&mut self, visible: bool) {
-        self.output.visible = Some(visible);
-    }
-
-    /// On desktop: Set the window always on top.
-    ///
-    /// (Wayland desktop currently not supported)
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_always_on_top(&mut self, always_on_top: bool) {
-        self.output.always_on_top = Some(always_on_top);
-    }
-
-    /// On desktop: Set the window to be centered.
-    ///
-    /// (Wayland desktop currently not supported)
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn set_centered(&mut self) {
-        if let Some(monitor_size) = self.info.window_info.monitor_size {
-            let inner_size = self.info.window_info.size;
-            if monitor_size.x > 1.0 && monitor_size.y > 1.0 {
-                let x = (monitor_size.x - inner_size.x) / 2.0;
-                let y = (monitor_size.y - inner_size.y) / 2.0;
-                self.set_window_pos(egui::Pos2 { x, y });
-            }
-        }
-    }
-
     /// for integrations only: call once per frame
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    #[doc(hidden)]
-    pub(crate) fn take_app_output(&mut self) -> backend::AppOutput {
+    pub fn take_app_output(&mut self) -> backend::AppOutput {
         std::mem::take(&mut self.output)
     }
 }
 
 /// Information about the web environment (if applicable).
 #[derive(Clone, Debug)]
-#[cfg(target_arch = "wasm32")]
 pub struct WebInfo {
-    /// The browser user agent.
-    pub user_agent: String,
-
     /// Information about the URL.
     pub location: Location,
 }
 
 /// Information about the application's main window, if available.
-#[cfg(not(target_arch = "wasm32"))]
 #[derive(Clone, Debug)]
 pub struct WindowInfo {
     /// Coordinates of the window's outer top left corner, relative to the top left corner of the first display.
-    ///
     /// Unit: egui points (logical pixels).
-    ///
+    pub position: egui::Pos2,
-    /// `None` = unknown.
-    pub position: Option<egui::Pos2>,
-
-    /// Are we in fullscreen mode?
-    pub fullscreen: bool,
-
-    /// Are we minimized?
-    pub minimized: bool,
-
-    /// Are we maximized?
-    pub maximized: bool,
 
     /// Window inner size in egui points (logical pixels).
     pub size: egui::Vec2,
-
-    /// Current monitor size in egui points (logical pixels)
-    pub monitor_size: Option<egui::Vec2>,
 }
 
 /// Information about the URL.
 ///
 /// Everything has been percent decoded (`%20` -> ` ` etc).
-#[cfg(target_arch = "wasm32")]
 #[derive(Clone, Debug)]
 pub struct Location {
     /// The full URL (`location.href`) without the hash.
@@ -936,9 +625,8 @@ pub struct Location {
 /// Information about the integration passed to the use app each frame.
 #[derive(Clone, Debug)]
 pub struct IntegrationInfo {
-    /// Information about the surrounding web environment.
+    /// If the app is running in a Web context, this returns information about the environment.
-    #[cfg(target_arch = "wasm32")]
+    pub web_info: Option<WebInfo>,
-    pub web_info: WebInfo,
 
     /// Does the OS use dark or light mode?
     ///
@@ -952,9 +640,8 @@ pub struct IntegrationInfo {
     /// The OS native pixels-per-point
     pub native_pixels_per_point: Option<f32>,
 
-    /// The position and size of the native window.
+    /// Window-specific geometry information, if provided by the platform.
-    #[cfg(not(target_arch = "wasm32"))]
+    pub window_info: Option<WindowInfo>,
-    pub window_info: WindowInfo,
 }
 
 // ----------------------------------------------------------------------------
@@ -968,7 +655,6 @@ pub struct IntegrationInfo {
 pub trait Storage {
     /// Get the value for the given key.
     fn get_string(&self, key: &str) -> Option<String>;
-
     /// Set the value for the given key.
     fn set_string(&mut self, key: &str, value: String);
 
@@ -984,9 +670,7 @@ impl Storage for DummyStorage {
     fn get_string(&self, _key: &str) -> Option<String> {
         None
     }
-
     fn set_string(&mut self, _key: &str, _value: String) {}
-
     fn flush(&mut self) {}
 }
 
@@ -1001,10 +685,7 @@ pub fn get_value<T: serde::de::DeserializeOwned>(storage: &dyn Storage, key: &st
 /// Serialize the given value as [RON](https://github.com/ron-rs/ron) and store with the given key.
 #[cfg(feature = "ron")]
 pub fn set_value<T: serde::Serialize>(storage: &mut dyn Storage, key: &str, value: &T) {
-    match ron::ser::to_string(value) {
+    storage.set_string(key, ron::ser::to_string(value).unwrap());
-        Ok(string) => storage.set_string(key, string),
-        Err(err) => tracing::error!("eframe failed to encode data using ron: {}", err),
-    }
 }
 
 /// [`Storage`] key used for app
@@ -1013,53 +694,29 @@ pub const APP_KEY: &str = "app";
 // ----------------------------------------------------------------------------
 
 /// You only need to look here if you are writing a backend for `epi`.
-pub(crate) mod backend {
+#[doc(hidden)]
+pub mod backend {
     /// Action that can be taken by the user app.
     #[derive(Clone, Debug, Default)]
     #[must_use]
     pub struct AppOutput {
-        /// Set to `true` to close the native window (which often quits the app).
+        /// Set to `true` to stop the app.
-        #[cfg(not(target_arch = "wasm32"))]
+        /// This does nothing for web apps.
-        pub close: bool,
+        pub quit: bool,
 
         /// Set to some size to resize the outer window (e.g. glium window) to this size.
-        #[cfg(not(target_arch = "wasm32"))]
         pub window_size: Option<egui::Vec2>,
 
         /// Set to some string to rename the outer window (e.g. glium window) to this title.
-        #[cfg(not(target_arch = "wasm32"))]
         pub window_title: Option<String>,
 
         /// Set to some bool to change window decorations.
-        #[cfg(not(target_arch = "wasm32"))]
         pub decorated: Option<bool>,
 
-        /// Set to some bool to change window fullscreen.
-        #[cfg(not(target_arch = "wasm32"))] // TODO: implement fullscreen on web
-        pub fullscreen: Option<bool>,
-
         /// Set to true to drag window while primary mouse button is down.
-        #[cfg(not(target_arch = "wasm32"))]
         pub drag_window: bool,
 
         /// Set to some position to move the outer window (e.g. glium window) to this position
-        #[cfg(not(target_arch = "wasm32"))]
         pub window_pos: Option<egui::Pos2>,
-
-        /// Set to some bool to change window visibility.
-        #[cfg(not(target_arch = "wasm32"))]
-        pub visible: Option<bool>,
-
-        /// Set to some bool to tell the window always on top.
-        #[cfg(not(target_arch = "wasm32"))]
-        pub always_on_top: Option<bool>,
-
-        /// Set to some bool to minimize or unminimize window.
-        #[cfg(not(target_arch = "wasm32"))]
-        pub minimized: Option<bool>,
-
-        /// Set to some bool to maximize or unmaximize window.
-        #[cfg(not(target_arch = "wasm32"))]
-        pub maximized: Option<bool>,
     }
 }

eframe/src/lib.rs

@@ -48,9 +48,8 @@
 //! /// Call this once from the HTML.
 //! #[cfg(target_arch = "wasm32")]
 //! #[wasm_bindgen]
-//! pub async fn start(canvas_id: &str) -> Result<AppRunnerRef, eframe::wasm_bindgen::JsValue> {
+//! pub fn start(canvas_id: &str) -> Result<(), eframe::wasm_bindgen::JsValue> {
-//!     let web_options = eframe::WebOptions::default();
+//!     eframe::start_web(canvas_id, Box::new(|cc| Box::new(MyApp::new(cc))))
-//!     eframe::start_web(canvas_id, web_options, Box::new(|cc| Box::new(MyEguiApp::new(cc)))).await
 //! }
 //! ```
 //!
@@ -78,14 +77,11 @@ pub use epi::*;
 // When compiling for web
 
 #[cfg(target_arch = "wasm32")]
-pub mod web;
+mod web;
 
 #[cfg(target_arch = "wasm32")]
 pub use wasm_bindgen;
 
-#[cfg(target_arch = "wasm32")]
-use web::AppRunnerRef;
-
 #[cfg(target_arch = "wasm32")]
 pub use web_sys;
 
@@ -97,47 +93,30 @@ pub use web_sys;
 /// use wasm_bindgen::prelude::*;
 ///
 /// /// This is the entry-point for all the web-assembly.
-/// /// This is called from the HTML.
+/// /// This is called once from the HTML.
 /// /// It loads the app, installs some callbacks, then returns.
-/// /// It returns a handle to the running app that can be stopped calling `AppRunner::stop_web`.
 /// /// You can add more callbacks like this if you want to call in to your code.
 /// #[cfg(target_arch = "wasm32")]
 /// #[wasm_bindgen]
-/// pub struct WebHandle {
+/// pub fn start(canvas_id: &str) -> Result<(), eframe::wasm_bindgen::JsValue> {
-///     handle: AppRunnerRef,
-/// }
-/// #[cfg(target_arch = "wasm32")]
-/// #[wasm_bindgen]
-/// pub async fn start(canvas_id: &str) -> Result<WebHandle, eframe::wasm_bindgen::JsValue> {
 ///     let web_options = eframe::WebOptions::default();
-///     eframe::start_web(
+///     eframe::start_web(canvas_id, web_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))))
-///         canvas_id,
-///         web_options,
-///         Box::new(|cc| Box::new(MyEguiApp::new(cc))),
-///     )
-///     .await
-///     .map(|handle| WebHandle { handle })
 /// }
 /// ```
-///
-/// # Errors
-/// Failing to initialize WebGL graphics.
 #[cfg(target_arch = "wasm32")]
-pub async fn start_web(
+pub fn start_web(
     canvas_id: &str,
     web_options: WebOptions,
     app_creator: AppCreator,
-) -> std::result::Result<AppRunnerRef, wasm_bindgen::JsValue> {
+) -> Result<(), wasm_bindgen::JsValue> {
-    let handle = web::start(canvas_id, web_options, app_creator).await?;
+    web::start(canvas_id, web_options, app_creator)?;
-
+    Ok(())
-    Ok(handle)
 }
 
 // ----------------------------------------------------------------------------
 // When compiling natively
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
 mod native;
 
 /// This is how you start a native (desktop) app.
@@ -175,88 +154,46 @@ mod native;
 ///    }
 /// }
 /// ```
-///
-/// # Errors
-/// This function can fail if we fail to set up a graphics context.
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(clippy::needless_pass_by_value)]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub fn run_native(app_name: &str, native_options: NativeOptions, app_creator: AppCreator) -> ! {
-pub fn run_native(
-    app_name: &str,
-    native_options: NativeOptions,
-    app_creator: AppCreator,
-) -> Result<()> {
     let renderer = native_options.renderer;
 
-    #[cfg(not(feature = "__screenshot"))]
-    assert!(
-        std::env::var("EFRAME_SCREENSHOT_TO").is_err(),
-        "EFRAME_SCREENSHOT_TO found without compiling with the '__screenshot' feature"
-    );
-
     match renderer {
         #[cfg(feature = "glow")]
         Renderer::Glow => {
             tracing::debug!("Using the glow renderer");
-            native::run::run_glow(app_name, native_options, app_creator)
+            native::run::run_glow(app_name, &native_options, app_creator)
         }
 
         #[cfg(feature = "wgpu")]
         Renderer::Wgpu => {
             tracing::debug!("Using the wgpu renderer");
-            native::run::run_wgpu(app_name, native_options, app_creator)
+            native::run::run_wgpu(app_name, &native_options, app_creator)
         }
     }
 }
 
-// ----------------------------------------------------------------------------
-
-/// The different problems that can occur when trying to run `eframe`.
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[cfg(not(target_arch = "wasm32"))]
-    #[error("winit error: {0}")]
-    Winit(#[from] winit::error::OsError),
-
-    #[cfg(all(feature = "glow", not(target_arch = "wasm32")))]
-    #[error("glutin error: {0}")]
-    Glutin(#[from] glutin::error::Error),
-
-    #[cfg(all(feature = "glow", not(target_arch = "wasm32")))]
-    #[error("Found no glutin configs matching the template: {0:?}. error: {1:?}")]
-    NoGlutinConfigs(glutin::config::ConfigTemplate, Box<dyn std::error::Error>),
-
-    #[cfg(feature = "wgpu")]
-    #[error("WGPU error: {0}")]
-    Wgpu(#[from] egui_wgpu::WgpuError),
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
 // ---------------------------------------------------------------------------
 
+/// Profiling macro for feature "puffin"
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+macro_rules! profile_function {
-mod profiling_scopes {
-    /// Profiling macro for feature "puffin"
-    macro_rules! profile_function {
     ($($arg: tt)*) => {
         #[cfg(feature = "puffin")]
         puffin::profile_function!($($arg)*);
     };
 }
-    pub(crate) use profile_function;
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) use profile_function;
 
-    /// Profiling macro for feature "puffin"
+/// Profiling macro for feature "puffin"
-    macro_rules! profile_scope {
+#[cfg(not(target_arch = "wasm32"))]
+macro_rules! profile_scope {
     ($($arg: tt)*) => {
         #[cfg(feature = "puffin")]
         puffin::profile_scope!($($arg)*);
     };
 }
-    pub(crate) use profile_scope;
-}
-
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub(crate) use profile_scope;
-pub(crate) use profiling_scopes::*;

eframe/src/native/epi_integration.rs

@@ -1,24 +1,6 @@
-use winit::event_loop::EventLoopWindowTarget;
-
-#[cfg(target_os = "macos")]
-use winit::platform::macos::WindowBuilderExtMacOS as _;
-
-#[cfg(feature = "accesskit")]
-use egui::accesskit;
-use egui::NumExt as _;
-#[cfg(feature = "accesskit")]
-use egui_winit::accesskit_winit;
-use egui_winit::{native_pixels_per_point, EventResponse, WindowSettings};
-
 use crate::{epi, Theme, WindowInfo};
-
+use egui_winit::{native_pixels_per_point, WindowSettings};
-#[derive(Default)]
+use winit::event_loop::EventLoopWindowTarget;
-pub struct WindowState {
-    // We cannot simply call `winit::Window::is_minimized/is_maximized`
-    // because that deadlocks on mac.
-    pub minimized: bool,
-    pub maximized: bool,
-}
 
 pub fn points_to_size(points: egui::Vec2) -> winit::dpi::LogicalSize<f64> {
     winit::dpi::LogicalSize {
@@ -30,53 +12,33 @@ pub fn points_to_size(points: egui::Vec2) -> winit::dpi::LogicalSize<f64> {
 pub fn read_window_info(
     window: &winit::window::Window,
     pixels_per_point: f32,
-    window_state: &WindowState,
+) -> Option<WindowInfo> {
-) -> WindowInfo {
+    match window.outer_position() {
-    let position = window
+        Ok(pos) => {
-        .outer_position()
+            let pos = pos.to_logical::<f32>(pixels_per_point.into());
-        .ok()
-        .map(|pos| pos.to_logical::<f32>(pixels_per_point.into()))
-        .map(|pos| egui::Pos2 { x: pos.x, y: pos.y });
-
-    let monitor = window.current_monitor().is_some();
-    let monitor_size = if monitor {
-        let size = window.current_monitor().unwrap().size();
-        Some(egui::vec2(size.width as _, size.height as _))
-    } else {
-        None
-    };
-
             let size = window
                 .inner_size()
                 .to_logical::<f32>(pixels_per_point.into());
-
+            Some(WindowInfo {
-    // NOTE: calling window.is_minimized() or window.is_maximized() deadlocks on Mac.
+                position: egui::Pos2 { x: pos.x, y: pos.y },
-
-    WindowInfo {
-        position,
-        fullscreen: window.fullscreen().is_some(),
-        minimized: window_state.minimized,
-        maximized: window_state.maximized,
                 size: egui::Vec2 {
                     x: size.width,
                     y: size.height,
                 },
-        monitor_size,
+            })
+        }
+        Err(_) => None,
     }
 }
 
-pub fn window_builder<E>(
+pub fn window_builder(
-    event_loop: &EventLoopWindowTarget<E>,
-    title: &str,
     native_options: &epi::NativeOptions,
-    window_settings: Option<WindowSettings>,
+    window_settings: &Option<WindowSettings>,
 ) -> winit::window::WindowBuilder {
     let epi::NativeOptions {
+        always_on_top,
         maximized,
         decorated,
-        fullscreen,
-        #[cfg(target_os = "macos")]
-        fullsize_content,
         drag_and_drop_support,
         icon_data,
         initial_window_pos,
@@ -85,31 +47,18 @@ pub fn window_builder<E>(
         max_window_size,
         resizable,
         transparent,
-        centered,
         ..
     } = native_options;
 
     let window_icon = icon_data.clone().and_then(load_icon);
 
     let mut window_builder = winit::window::WindowBuilder::new()
-        .with_title(title)
+        .with_always_on_top(*always_on_top)
-        .with_decorations(*decorated)
-        .with_fullscreen(fullscreen.then(|| winit::window::Fullscreen::Borderless(None)))
         .with_maximized(*maximized)
+        .with_decorations(*decorated)
         .with_resizable(*resizable)
         .with_transparent(*transparent)
-        .with_window_icon(window_icon)
+        .with_window_icon(window_icon);
-        // Keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
-        // We must also keep the window hidden until AccessKit is initialized.
-        .with_visible(false);
-
-    #[cfg(target_os = "macos")]
-    if *fullsize_content {
-        window_builder = window_builder
-            .with_title_hidden(true)
-            .with_titlebar_transparent(true)
-            .with_fullsize_content_view(true);
-    }
 
     if let Some(min_size) = *min_window_size {
         window_builder = window_builder.with_min_inner_size(points_to_size(min_size));
@@ -120,75 +69,23 @@ pub fn window_builder<E>(
 
     window_builder = window_builder_drag_and_drop(window_builder, *drag_and_drop_support);
 
-    let inner_size_points = if let Some(mut window_settings) = window_settings {
+    if let Some(window_settings) = window_settings {
-        // Restore pos/size from previous session
-        window_settings.clamp_to_sane_values(largest_monitor_point_size(event_loop));
-        #[cfg(windows)]
-        window_settings.clamp_window_to_sane_position(&event_loop);
         window_builder = window_settings.initialize_window(window_builder);
-        window_settings.inner_size_points()
     } else {
         if let Some(pos) = *initial_window_pos {
-            window_builder = window_builder.with_position(winit::dpi::LogicalPosition {
+            window_builder = window_builder.with_position(winit::dpi::PhysicalPosition {
                 x: pos.x as f64,
                 y: pos.y as f64,
             });
         }
-
         if let Some(initial_window_size) = *initial_window_size {
-            let initial_window_size =
-                initial_window_size.at_most(largest_monitor_point_size(event_loop));
             window_builder = window_builder.with_inner_size(points_to_size(initial_window_size));
         }
+    }
 
-        *initial_window_size
-    };
-
-    if *centered {
-        if let Some(monitor) = event_loop.available_monitors().next() {
-            let monitor_size = monitor.size();
-            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
-            if monitor_size.width > 0 && monitor_size.height > 0 {
-                let x = (monitor_size.width - inner_size.x as u32) / 2;
-                let y = (monitor_size.height - inner_size.y as u32) / 2;
-                window_builder = window_builder.with_position(winit::dpi::LogicalPosition {
-                    x: x as f64,
-                    y: y as f64,
-                });
-            }
-        }
-    }
     window_builder
 }
 
-pub fn apply_native_options_to_window(
-    window: &winit::window::Window,
-    native_options: &crate::NativeOptions,
-) {
-    use winit::window::WindowLevel;
-    window.set_window_level(if native_options.always_on_top {
-        WindowLevel::AlwaysOnTop
-    } else {
-        WindowLevel::Normal
-    });
-}
-
-fn largest_monitor_point_size<E>(event_loop: &EventLoopWindowTarget<E>) -> egui::Vec2 {
-    let mut max_size = egui::Vec2::ZERO;
-
-    for monitor in event_loop.available_monitors() {
-        let size = monitor.size().to_logical::<f32>(monitor.scale_factor());
-        let size = egui::vec2(size.width, size.height);
-        max_size = max_size.max(size);
-    }
-
-    if max_size == egui::Vec2::ZERO {
-        egui::Vec2::splat(16000.0)
-    } else {
-        max_size
-    }
-}
-
 fn load_icon(icon_data: epi::IconData) -> Option<winit::window::Icon> {
     winit::window::Icon::from_rgba(icon_data.rgba, icon_data.width, icon_data.height).ok()
 }
@@ -215,20 +112,14 @@ pub fn handle_app_output(
     window: &winit::window::Window,
     current_pixels_per_point: f32,
     app_output: epi::backend::AppOutput,
-    window_state: &mut WindowState,
 ) {
     let epi::backend::AppOutput {
-        close: _,
+        quit: _,
         window_size,
         window_title,
         decorated,
-        fullscreen,
         drag_window,
         window_pos,
-        visible: _, // handled in post_present
-        always_on_top,
-        minimized,
-        maximized,
     } = app_output;
 
     if let Some(decorated) = decorated {
@@ -245,10 +136,6 @@ pub fn handle_app_output(
         );
     }
 
-    if let Some(fullscreen) = fullscreen {
-        window.set_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None)));
-    }
-
     if let Some(window_title) = window_title {
         window.set_title(&window_title);
     }
@@ -263,25 +150,6 @@ pub fn handle_app_output(
     if drag_window {
         let _ = window.drag_window();
     }
-
-    if let Some(always_on_top) = always_on_top {
-        use winit::window::WindowLevel;
-        window.set_window_level(if always_on_top {
-            WindowLevel::AlwaysOnTop
-        } else {
-            WindowLevel::Normal
-        });
-    }
-
-    if let Some(minimized) = minimized {
-        window.set_minimized(minimized);
-        window_state.minimized = minimized;
-    }
-
-    if let Some(maximized) = maximized {
-        window.set_maximized(maximized);
-        window_state.maximized = maximized;
-    }
 }
 
 // ----------------------------------------------------------------------------
@@ -304,10 +172,9 @@ pub struct EpiIntegration {
     pub egui_ctx: egui::Context,
     pending_full_output: egui::FullOutput,
     egui_winit: egui_winit::State,
-    /// When set, it is time to close the native window.
+    /// When set, it is time to quit
-    close: bool,
+    quit: bool,
     can_drag_window: bool,
-    window_state: WindowState,
 }
 
 impl EpiIntegration {
@@ -318,41 +185,32 @@ impl EpiIntegration {
         system_theme: Option<Theme>,
         storage: Option<Box<dyn epi::Storage>>,
         #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
-        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+        #[cfg(feature = "wgpu")] render_state: Option<egui_wgpu::RenderState>,
     ) -> Self {
         let egui_ctx = egui::Context::default();
 
-        let memory = load_egui_memory(storage.as_deref()).unwrap_or_default();
+        *egui_ctx.memory() = load_egui_memory(storage.as_deref()).unwrap_or_default();
-        egui_ctx.memory_mut(|mem| *mem = memory);
-
-        let native_pixels_per_point = window.scale_factor() as f32;
-
-        let window_state = WindowState {
-            minimized: window.is_minimized().unwrap_or(false),
-            maximized: window.is_maximized(),
-        };
 
         let frame = epi::Frame {
             info: epi::IntegrationInfo {
+                web_info: None,
                 system_theme,
                 cpu_usage: None,
-                native_pixels_per_point: Some(native_pixels_per_point),
+                native_pixels_per_point: Some(native_pixels_per_point(window)),
-                window_info: read_window_info(window, egui_ctx.pixels_per_point(), &window_state),
+                window_info: read_window_info(window, egui_ctx.pixels_per_point()),
-            },
-            output: epi::backend::AppOutput {
-                visible: Some(true),
-                ..Default::default()
             },
+            output: Default::default(),
             storage,
             #[cfg(feature = "glow")]
             gl,
             #[cfg(feature = "wgpu")]
-            wgpu_render_state,
+            render_state,
         };
 
         let mut egui_winit = egui_winit::State::new(event_loop);
         egui_winit.set_max_texture_side(max_texture_side);
-        egui_winit.set_pixels_per_point(native_pixels_per_point);
+        let pixels_per_point = window.scale_factor() as f32;
+        egui_winit.set_pixels_per_point(pixels_per_point);
 
         Self {
             frame,
@@ -360,81 +218,41 @@ impl EpiIntegration {
             egui_ctx,
             egui_winit,
             pending_full_output: Default::default(),
-            close: false,
+            quit: false,
             can_drag_window: false,
-            window_state,
         }
     }
 
-    #[cfg(feature = "accesskit")]
-    pub fn init_accesskit<E: From<accesskit_winit::ActionRequestEvent> + Send>(
-        &mut self,
-        window: &winit::window::Window,
-        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
-    ) {
-        let egui_ctx = self.egui_ctx.clone();
-        self.egui_winit
-            .init_accesskit(window, event_loop_proxy, move || {
-                // This function is called when an accessibility client
-                // (e.g. screen reader) makes its first request. If we got here,
-                // we know that an accessibility tree is actually wanted.
-                egui_ctx.enable_accesskit();
-                // Enqueue a repaint so we'll receive a full tree update soon.
-                egui_ctx.request_repaint();
-                egui_ctx.accesskit_placeholder_tree_update()
-            });
-    }
-
     pub fn warm_up(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
         crate::profile_function!();
-        let saved_memory: egui::Memory = self.egui_ctx.memory(|mem| mem.clone());
+        let saved_memory: egui::Memory = self.egui_ctx.memory().clone();
-        self.egui_ctx
+        self.egui_ctx.memory().set_everything_is_visible(true);
-            .memory_mut(|mem| mem.set_everything_is_visible(true));
         let full_output = self.update(app, window);
         self.pending_full_output.append(full_output); // Handle it next frame
-        self.egui_ctx.memory_mut(|mem| *mem = saved_memory); // We don't want to remember that windows were huge.
+        *self.egui_ctx.memory() = saved_memory; // We don't want to remember that windows were huge.
         self.egui_ctx.clear_animations();
     }
 
-    /// If `true`, it is time to close the native window.
+    /// If `true`, it is time to shut down.
-    pub fn should_close(&self) -> bool {
+    pub fn should_quit(&self) -> bool {
-        self.close
+        self.quit
     }
 
-    pub fn on_event(
+    pub fn on_event(&mut self, app: &mut dyn epi::App, event: &winit::event::WindowEvent<'_>) {
-        &mut self,
-        app: &mut dyn epi::App,
-        event: &winit::event::WindowEvent<'_>,
-    ) -> EventResponse {
         use winit::event::{ElementState, MouseButton, WindowEvent};
 
         match event {
-            WindowEvent::CloseRequested => {
+            WindowEvent::CloseRequested => self.quit = app.on_exit_event(),
-                tracing::debug!("Received WindowEvent::CloseRequested");
+            WindowEvent::Destroyed => self.quit = true,
-                self.close = app.on_close_event();
-                tracing::debug!("App::on_close_event returned {}", self.close);
-            }
-            WindowEvent::Destroyed => {
-                tracing::debug!("Received WindowEvent::Destroyed");
-                self.close = true;
-            }
             WindowEvent::MouseInput {
                 button: MouseButton::Left,
                 state: ElementState::Pressed,
                 ..
             } => self.can_drag_window = true,
-            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
-                self.frame.info.native_pixels_per_point = Some(*scale_factor as _);
-            }
             _ => {}
         }
 
-        self.egui_winit.on_event(&self.egui_ctx, event)
+        self.egui_winit.on_event(&self.egui_ctx, event);
-    }
-
-    #[cfg(feature = "accesskit")]
-    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
-        self.egui_winit.on_accesskit_action_request(request);
     }
 
     pub fn update(
@@ -444,16 +262,12 @@ impl EpiIntegration {
     ) -> egui::FullOutput {
         let frame_start = std::time::Instant::now();
 
-        self.frame.info.window_info =
+        self.frame.info.window_info = read_window_info(window, self.egui_ctx.pixels_per_point());
-            read_window_info(window, self.egui_ctx.pixels_per_point(), &self.window_state);
         let raw_input = self.egui_winit.take_egui_input(window);
-
-        // Run user code:
         let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
             crate::profile_scope!("App::update");
             app.update(egui_ctx, &mut self.frame);
         });
-
         self.pending_full_output.append(full_output);
         let full_output = std::mem::take(&mut self.pending_full_output);
 
@@ -461,20 +275,13 @@ impl EpiIntegration {
             let mut app_output = self.frame.take_app_output();
             app_output.drag_window &= self.can_drag_window; // Necessary on Windows; see https://github.com/emilk/egui/pull/1108
             self.can_drag_window = false;
-            if app_output.close {
+            if app_output.quit {
-                self.close = app.on_close_event();
+                self.quit = app.on_exit_event();
-                tracing::debug!("App::on_close_event returned {}", self.close);
             }
-            self.frame.output.visible = app_output.visible; // this is handled by post_present
+            handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
-            handle_app_output(
-                window,
-                self.egui_ctx.pixels_per_point(),
-                app_output,
-                &mut self.window_state,
-            );
         }
 
-        let frame_time = frame_start.elapsed().as_secs_f64() as f32;
+        let frame_time = (std::time::Instant::now() - frame_start).as_secs_f64() as f32;
         self.frame.info.cpu_usage = Some(frame_time);
 
         full_output
@@ -487,12 +294,6 @@ impl EpiIntegration {
         app.post_rendering(window_size_px, &self.frame);
     }
 
-    pub fn post_present(&mut self, window: &winit::window::Window) {
-        if let Some(visible) = self.frame.output.visible.take() {
-            window.set_visible(visible);
-        }
-    }
-
     pub fn handle_platform_output(
         &mut self,
         window: &winit::window::Window,
@@ -528,8 +329,7 @@ impl EpiIntegration {
             }
             if _app.persist_egui_memory() {
                 crate::profile_scope!("egui_memory");
-                self.egui_ctx
+                epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, &*self.egui_ctx.memory());
-                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
             }
             {
                 crate::profile_scope!("App::save");
@@ -544,7 +344,6 @@ impl EpiIntegration {
 
 #[cfg(feature = "persistence")]
 const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
-
 #[cfg(feature = "persistence")]
 const STORAGE_WINDOW_KEY: &str = "window";
 

eframe/src/native/file_storage.rs

@@ -26,7 +26,6 @@ impl FileStorage {
     /// Store the state in this .ron file.
     pub fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
         let ron_filepath: PathBuf = ron_filepath.into();
-        tracing::debug!("Loading app state from {:?}…", ron_filepath);
         Self {
             kv: read_ron(&ron_filepath).unwrap_or_default(),
             ron_filepath,

eframe/src/native/run.rs

@@ -0,0 +1,428 @@
+use super::epi_integration;
+use crate::epi;
+use egui_winit::winit;
+
+struct RequestRepaintEvent;
+
+#[cfg(feature = "glow")]
+#[allow(unsafe_code)]
+fn create_display(
+    native_options: &NativeOptions,
+    window_builder: winit::window::WindowBuilder,
+    event_loop: &winit::event_loop::EventLoop<RequestRepaintEvent>,
+) -> (
+    glutin::WindowedContext<glutin::PossiblyCurrent>,
+    glow::Context,
+) {
+    crate::profile_function!();
+
+    use crate::HardwareAcceleration;
+
+    let hardware_acceleration = match native_options.hardware_acceleration {
+        HardwareAcceleration::Required => Some(true),
+        HardwareAcceleration::Preferred => None,
+        HardwareAcceleration::Off => Some(false),
+    };
+
+    let gl_window = unsafe {
+        glutin::ContextBuilder::new()
+            .with_hardware_acceleration(hardware_acceleration)
+            .with_depth_buffer(native_options.depth_buffer)
+            .with_multisampling(native_options.multisampling)
+            .with_srgb(true)
+            .with_stencil_buffer(native_options.stencil_buffer)
+            .with_vsync(native_options.vsync)
+            .build_windowed(window_builder, event_loop)
+            .unwrap()
+            .make_current()
+            .unwrap()
+    };
+
+    let gl = unsafe { glow::Context::from_loader_function(|s| gl_window.get_proc_address(s)) };
+
+    (gl_window, gl)
+}
+
+// ----------------------------------------------------------------------------
+
+pub use epi::NativeOptions;
+
+/// Run an egui app
+#[cfg(feature = "glow")]
+pub fn run_glow(
+    app_name: &str,
+    native_options: &epi::NativeOptions,
+    app_creator: epi::AppCreator,
+) -> ! {
+    let storage = epi_integration::create_storage(app_name);
+    let window_settings = epi_integration::load_window_settings(storage.as_deref());
+    let event_loop = winit::event_loop::EventLoop::with_user_event();
+
+    let window_builder =
+        epi_integration::window_builder(native_options, &window_settings).with_title(app_name);
+    let (gl_window, gl) = create_display(native_options, window_builder, &event_loop);
+    let gl = std::sync::Arc::new(gl);
+
+    let mut painter = egui_glow::Painter::new(gl.clone(), None, "")
+        .unwrap_or_else(|error| panic!("some OpenGL error occurred {}\n", error));
+
+    let system_theme = native_options.system_theme();
+    let mut integration = epi_integration::EpiIntegration::new(
+        &event_loop,
+        painter.max_texture_side(),
+        gl_window.window(),
+        system_theme,
+        storage,
+        Some(gl.clone()),
+        #[cfg(feature = "wgpu")]
+        None,
+    );
+    let theme = system_theme.unwrap_or(native_options.default_theme);
+    integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+    {
+        let event_loop_proxy = egui::mutex::Mutex::new(event_loop.create_proxy());
+        integration.egui_ctx.set_request_repaint_callback(move || {
+            event_loop_proxy.lock().send_event(RequestRepaintEvent).ok();
+        });
+    }
+
+    let mut app = app_creator(&epi::CreationContext {
+        egui_ctx: integration.egui_ctx.clone(),
+        integration_info: integration.frame.info(),
+        storage: integration.frame.storage(),
+        gl: Some(gl.clone()),
+        #[cfg(feature = "wgpu")]
+        render_state: None,
+    });
+
+    if app.warm_up_enabled() {
+        integration.warm_up(app.as_mut(), gl_window.window());
+    }
+
+    let mut is_focused = true;
+
+    event_loop.run(move |event, _, control_flow| {
+        let window = gl_window.window();
+
+        let mut redraw = || {
+            #[cfg(feature = "puffin")]
+            puffin::GlobalProfiler::lock().new_frame();
+            crate::profile_scope!("frame");
+
+            let screen_size_in_pixels: [u32; 2] = window.inner_size().into();
+
+            egui_glow::painter::clear(
+                &gl,
+                screen_size_in_pixels,
+                app.clear_color(&integration.egui_ctx.style().visuals),
+            );
+
+            let egui::FullOutput {
+                platform_output,
+                repaint_after,
+                textures_delta,
+                shapes,
+            } = integration.update(app.as_mut(), window);
+
+            integration.handle_platform_output(window, platform_output);
+
+            let clipped_primitives = {
+                crate::profile_scope!("tessellate");
+                integration.egui_ctx.tessellate(shapes)
+            };
+
+            painter.paint_and_update_textures(
+                screen_size_in_pixels,
+                integration.egui_ctx.pixels_per_point(),
+                &clipped_primitives,
+                &textures_delta,
+            );
+
+            integration.post_rendering(app.as_mut(), window);
+
+            {
+                crate::profile_scope!("swap_buffers");
+                gl_window.swap_buffers().unwrap();
+            }
+
+            *control_flow = if integration.should_quit() {
+                winit::event_loop::ControlFlow::Exit
+            } else if repaint_after.is_zero() {
+                window.request_redraw();
+                winit::event_loop::ControlFlow::Poll
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                // if repaint_after is something huge and can't be added to Instant,
+                // we will use `ControlFlow::Wait` instead.
+                // technically, this might lead to some weird corner cases where the user *WANTS*
+                // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                // egui backend impl i guess.
+                winit::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
+            } else {
+                winit::event_loop::ControlFlow::Wait
+            };
+
+            integration.maybe_autosave(app.as_mut(), window);
+
+            if !is_focused {
+                // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                // But we know if we are focused (in foreground). When minimized, we are not focused.
+                // However, a user may want an egui with an animation in the background,
+                // so we still need to repaint quite fast.
+                crate::profile_scope!("bg_sleep");
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+        };
+        match event {
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+
+            winit::event::Event::WindowEvent { event, .. } => {
+                match &event {
+                    winit::event::WindowEvent::Focused(new_focused) => {
+                        is_focused = *new_focused;
+                    }
+                    winit::event::WindowEvent::Resized(physical_size) => {
+                        // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                        // See: https://github.com/rust-windowing/winit/issues/208
+                        // This solves an issue where the app would panic when minimizing on Windows.
+                        if physical_size.width > 0 && physical_size.height > 0 {
+                            gl_window.resize(*physical_size);
+                        }
+                    }
+                    winit::event::WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                        gl_window.resize(**new_inner_size);
+                    }
+                    winit::event::WindowEvent::CloseRequested if integration.should_quit() => {
+                        *control_flow = winit::event_loop::ControlFlow::Exit;
+                    }
+                    _ => {}
+                }
+
+                integration.on_event(app.as_mut(), &event);
+                if integration.should_quit() {
+                    *control_flow = winit::event_loop::ControlFlow::Exit;
+                }
+                window.request_redraw(); // TODO(emilk): ask egui if the events warrants a repaint instead
+            }
+            winit::event::Event::LoopDestroyed => {
+                integration.save(&mut *app, window);
+                app.on_exit(Some(&gl));
+                painter.destroy();
+            }
+            winit::event::Event::UserEvent(RequestRepaintEvent) => window.request_redraw(),
+            winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => {
+                window.request_redraw();
+            }
+            _ => {}
+        }
+    });
+}
+
+// TODO(emilk): merge with with the clone above
+/// Run an egui app
+#[cfg(feature = "wgpu")]
+pub fn run_wgpu(
+    app_name: &str,
+    native_options: &epi::NativeOptions,
+    app_creator: epi::AppCreator,
+) -> ! {
+    let storage = epi_integration::create_storage(app_name);
+    let window_settings = epi_integration::load_window_settings(storage.as_deref());
+    let event_loop = winit::event_loop::EventLoop::with_user_event();
+
+    let window = epi_integration::window_builder(native_options, &window_settings)
+        .with_title(app_name)
+        .build(&event_loop)
+        .unwrap();
+
+    // SAFETY: `window` must outlive `painter`.
+    #[allow(unsafe_code)]
+    let mut painter = unsafe {
+        let mut painter = egui_wgpu::winit::Painter::new(
+            wgpu::Backends::PRIMARY | wgpu::Backends::GL,
+            wgpu::PowerPreference::HighPerformance,
+            wgpu::DeviceDescriptor {
+                label: None,
+                features: wgpu::Features::default(),
+                limits: wgpu::Limits::default(),
+            },
+            wgpu::PresentMode::Fifo,
+            native_options.multisampling.max(1) as _,
+        );
+        #[cfg(not(target_os = "android"))]
+        painter.set_window(Some(&window));
+        painter
+    };
+
+    let render_state = painter.get_render_state().expect("Uninitialized");
+
+    let system_theme = native_options.system_theme();
+    let mut integration = epi_integration::EpiIntegration::new(
+        &event_loop,
+        painter.max_texture_side().unwrap_or(2048),
+        &window,
+        system_theme,
+        storage,
+        #[cfg(feature = "glow")]
+        None,
+        Some(render_state.clone()),
+    );
+    let theme = system_theme.unwrap_or(native_options.default_theme);
+    integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+    {
+        let event_loop_proxy = egui::mutex::Mutex::new(event_loop.create_proxy());
+        integration.egui_ctx.set_request_repaint_callback(move || {
+            event_loop_proxy.lock().send_event(RequestRepaintEvent).ok();
+        });
+    }
+
+    let mut app = app_creator(&epi::CreationContext {
+        egui_ctx: integration.egui_ctx.clone(),
+        integration_info: integration.frame.info(),
+        storage: integration.frame.storage(),
+        #[cfg(feature = "glow")]
+        gl: None,
+        render_state: Some(render_state),
+    });
+
+    if app.warm_up_enabled() {
+        integration.warm_up(app.as_mut(), &window);
+    }
+
+    let mut is_focused = true;
+
+    event_loop.run(move |event, _, control_flow| {
+        let window = &window;
+
+        let mut redraw = || {
+            #[cfg(feature = "puffin")]
+            puffin::GlobalProfiler::lock().new_frame();
+            crate::profile_scope!("frame");
+
+            let egui::FullOutput {
+                platform_output,
+                repaint_after,
+                textures_delta,
+                shapes,
+            } = integration.update(app.as_mut(), window);
+
+            integration.handle_platform_output(window, platform_output);
+
+            let clipped_primitives = {
+                crate::profile_scope!("tessellate");
+                integration.egui_ctx.tessellate(shapes)
+            };
+
+            painter.paint_and_update_textures(
+                integration.egui_ctx.pixels_per_point(),
+                app.clear_color(&integration.egui_ctx.style().visuals),
+                &clipped_primitives,
+                &textures_delta,
+            );
+
+            *control_flow = if integration.should_quit() {
+                winit::event_loop::ControlFlow::Exit
+            } else if repaint_after.is_zero() {
+                window.request_redraw();
+                winit::event_loop::ControlFlow::Poll
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                // if repaint_after is something huge and can't be added to Instant,
+                // we will use `ControlFlow::Wait` instead.
+                // technically, this might lead to some weird corner cases where the user *WANTS*
+                // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                // egui backend impl i guess.
+                winit::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
+            } else {
+                winit::event_loop::ControlFlow::Wait
+            };
+
+            integration.maybe_autosave(app.as_mut(), window);
+
+            if !is_focused {
+                // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                // But we know if we are focused (in foreground). When minimized, we are not focused.
+                // However, a user may want an egui with an animation in the background,
+                // so we still need to repaint quite fast.
+                crate::profile_scope!("bg_sleep");
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+        };
+
+        match event {
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+
+            #[cfg(target_os = "android")]
+            winit::event::Event::Resumed => unsafe {
+                painter.set_window(Some(&window));
+            },
+            #[cfg(target_os = "android")]
+            winit::event::Event::Paused => unsafe {
+                painter.set_window(None);
+            },
+
+            winit::event::Event::WindowEvent { event, .. } => {
+                match &event {
+                    winit::event::WindowEvent::Focused(new_focused) => {
+                        is_focused = *new_focused;
+                    }
+                    winit::event::WindowEvent::Resized(physical_size) => {
+                        // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                        // See: https://github.com/rust-windowing/winit/issues/208
+                        // This solves an issue where the app would panic when minimizing on Windows.
+                        if physical_size.width > 0 && physical_size.height > 0 {
+                            painter.on_window_resized(physical_size.width, physical_size.height);
+                        }
+                    }
+                    winit::event::WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                        painter.on_window_resized(new_inner_size.width, new_inner_size.height);
+                    }
+                    winit::event::WindowEvent::CloseRequested if integration.should_quit() => {
+                        *control_flow = winit::event_loop::ControlFlow::Exit;
+                    }
+                    _ => {}
+                };
+
+                integration.on_event(app.as_mut(), &event);
+                if integration.should_quit() {
+                    *control_flow = winit::event_loop::ControlFlow::Exit;
+                }
+                window.request_redraw(); // TODO(emilk): ask egui if the events warrants a repaint instead
+            }
+            winit::event::Event::LoopDestroyed => {
+                integration.save(&mut *app, window);
+
+                #[cfg(feature = "glow")]
+                app.on_exit(None);
+
+                #[cfg(not(feature = "glow"))]
+                app.on_exit();
+
+                painter.destroy();
+            }
+            winit::event::Event::UserEvent(RequestRepaintEvent) => window.request_redraw(),
+            winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => {
+                window.request_redraw();
+            }
+            _ => (),
+        }
+    });
+}

eframe/src/web/backend.rs

@@ -1,11 +1,11 @@
-use egui::{
+use super::{glow_wrapping::WrappedGlowPainter, *};
-    mutex::{Mutex, MutexGuard},
-    TexturesDelta,
-};
 
-use crate::{epi, App};
+use crate::epi;
 
-use super::{web_painter::WebPainter, *};
+use egui::mutex::{Mutex, MutexGuard};
+use egui::TexturesDelta;
+
+pub use egui::{pos2, Color32};
 
 // ----------------------------------------------------------------------------
 
@@ -67,30 +67,8 @@ impl NeedRepaint {
     }
 }
 
-pub struct IsDestroyed(std::sync::atomic::AtomicBool);
-
-impl Default for IsDestroyed {
-    fn default() -> Self {
-        Self(false.into())
-    }
-}
-
-impl IsDestroyed {
-    pub fn fetch(&self) -> bool {
-        self.0.load(SeqCst)
-    }
-
-    pub fn set_true(&self) {
-        self.0.store(true, SeqCst);
-    }
-}
-
 // ----------------------------------------------------------------------------
 
-fn user_agent() -> Option<String> {
-    web_sys::window()?.navigator().user_agent().ok()
-}
-
 fn web_location() -> epi::Location {
     let location = web_sys::window().unwrap().location();
 
@@ -105,7 +83,7 @@ fn web_location() -> epi::Location {
 
     let query_map = parse_query_map(&query)
         .iter()
-        .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+        .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
         .collect();
 
     epi::Location {
@@ -165,34 +143,24 @@ fn test_parse_query() {
 pub struct AppRunner {
     pub(crate) frame: epi::Frame,
     egui_ctx: egui::Context,
-    painter: ActiveWebPainter,
+    painter: WrappedGlowPainter,
     pub(crate) input: WebInput,
     app: Box<dyn epi::App>,
     pub(crate) needs_repaint: std::sync::Arc<NeedRepaint>,
-    pub(crate) is_destroyed: std::sync::Arc<IsDestroyed>,
     last_save_time: f64,
     screen_reader: super::screen_reader::ScreenReader,
     pub(crate) text_cursor_pos: Option<egui::Pos2>,
     pub(crate) mutable_text_under_cursor: bool,
     textures_delta: TexturesDelta,
-    pub events_to_unsubscribe: Vec<EventToUnsubscribe>,
-}
-
-impl Drop for AppRunner {
-    fn drop(&mut self) {
-        tracing::debug!("AppRunner has fully dropped");
-    }
 }
 
 impl AppRunner {
-    /// # Errors
+    pub fn new(
-    /// Failure to initialize WebGL renderer.
-    pub async fn new(
         canvas_id: &str,
         web_options: crate::WebOptions,
         app_creator: epi::AppCreator,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, JsValue> {
-        let painter = ActiveWebPainter::new(canvas_id, &web_options).await?;
+        let painter = WrappedGlowPainter::new(canvas_id).map_err(JsValue::from)?; // fail early
 
         let system_theme = if web_options.follow_system_theme {
             super::system_theme()
@@ -201,20 +169,17 @@ impl AppRunner {
         };
 
         let info = epi::IntegrationInfo {
-            web_info: epi::WebInfo {
+            web_info: Some(epi::WebInfo {
-                user_agent: user_agent().unwrap_or_default(),
                 location: web_location(),
-            },
+            }),
             system_theme,
             cpu_usage: None,
             native_pixels_per_point: Some(native_pixels_per_point()),
+            window_info: None,
         };
         let storage = LocalStorage::default();
 
         let egui_ctx = egui::Context::default();
-        egui_ctx.set_os(egui::os::OperatingSystem::from_user_agent(
-            &user_agent().unwrap_or_default(),
-        ));
         load_memory(&egui_ctx);
 
         let theme = system_theme.unwrap_or(web_options.default_theme);
@@ -224,28 +189,20 @@ impl AppRunner {
             egui_ctx: egui_ctx.clone(),
             integration_info: info.clone(),
             storage: Some(&storage),
-
             #[cfg(feature = "glow")]
-            gl: Some(painter.gl().clone()),
+            gl: Some(painter.painter.gl().clone()),
-
+            #[cfg(feature = "wgpu")]
-            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
+            render_state: None,
-            wgpu_render_state: painter.render_state(),
-            #[cfg(all(feature = "wgpu", feature = "glow"))]
-            wgpu_render_state: None,
         });
 
         let frame = epi::Frame {
             info,
             output: Default::default(),
             storage: Some(Box::new(storage)),
-
             #[cfg(feature = "glow")]
             gl: Some(painter.gl().clone()),
-
+            #[cfg(feature = "wgpu")]
-            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
+            render_state: None,
-            wgpu_render_state: painter.render_state(),
-            #[cfg(all(feature = "wgpu", feature = "glow"))]
-            wgpu_render_state: None,
         };
 
         let needs_repaint: std::sync::Arc<NeedRepaint> = Default::default();
@@ -263,13 +220,11 @@ impl AppRunner {
             input: Default::default(),
             app,
             needs_repaint,
-            is_destroyed: Default::default(),
             last_save_time: now_sec(),
             screen_reader: Default::default(),
             text_cursor_pos: None,
             mutable_text_under_cursor: false,
             textures_delta: Default::default(),
-            events_to_unsubscribe: Default::default(),
         };
 
         runner.input.raw.max_texture_side = Some(runner.painter.max_texture_side());
@@ -281,17 +236,6 @@ impl AppRunner {
         &self.egui_ctx
     }
 
-    /// Get mutable access to the concrete [`App`] we enclose.
-    ///
-    /// This will panic if your app does not implement [`App::as_any_mut`].
-    pub fn app_mut<ConreteApp: 'static + App>(&mut self) -> &mut ConreteApp {
-        self.app
-            .as_any_mut()
-            .expect("Your app must implement `as_any_mut`, but it doesn't")
-            .downcast_mut::<ConreteApp>()
-            .unwrap()
-    }
-
     pub fn auto_save(&mut self) {
         let now = now_sec();
         let time_since_last_save = now - self.last_save_time;
@@ -313,34 +257,15 @@ impl AppRunner {
 
     pub fn warm_up(&mut self) -> Result<(), JsValue> {
         if self.app.warm_up_enabled() {
-            let saved_memory: egui::Memory = self.egui_ctx.memory(|m| m.clone());
+            let saved_memory: egui::Memory = self.egui_ctx.memory().clone();
-            self.egui_ctx
+            self.egui_ctx.memory().set_everything_is_visible(true);
-                .memory_mut(|m| m.set_everything_is_visible(true));
             self.logic()?;
-            self.egui_ctx.memory_mut(|m| *m = saved_memory); // We don't want to remember that windows were huge.
+            *self.egui_ctx.memory() = saved_memory; // We don't want to remember that windows were huge.
             self.egui_ctx.clear_animations();
         }
         Ok(())
     }
 
-    pub fn destroy(&mut self) -> Result<(), JsValue> {
-        let is_destroyed_already = self.is_destroyed.fetch();
-
-        if is_destroyed_already {
-            tracing::warn!("App was destroyed already");
-            Ok(())
-        } else {
-            tracing::debug!("Destroying");
-            for x in self.events_to_unsubscribe.drain(..) {
-                x.unsubscribe()?;
-            }
-
-            self.painter.destroy();
-            self.is_destroyed.set_true();
-            Ok(())
-        }
-    }
-
     /// Returns how long to wait until the next repaint.
     ///
     /// Call [`Self::paint`] later to paint
@@ -367,19 +292,30 @@ impl AppRunner {
 
         {
             let app_output = self.frame.take_app_output();
-            let epi::backend::AppOutput {} = app_output;
+            let epi::backend::AppOutput {
+                quit: _,         // Can't quit a web page
+                window_size: _,  // Can't resize a web page
+                window_title: _, // TODO(emilk): change title of window
+                decorated: _,    // Can't toggle decorations
+                drag_window: _,  // Can't be dragged
+                window_pos: _,   // Can't set position of a web page
+            } = app_output;
         }
 
         self.frame.info.cpu_usage = Some((now_sec() - frame_start) as f32);
         Ok((repaint_after, clipped_primitives))
     }
 
+    pub fn clear_color_buffer(&self) {
+        self.painter
+            .clear(self.app.clear_color(&self.egui_ctx.style().visuals));
+    }
+
     /// Paint the results of the last call to [`Self::logic`].
     pub fn paint(&mut self, clipped_primitives: &[egui::ClippedPrimitive]) -> Result<(), JsValue> {
         let textures_delta = std::mem::take(&mut self.textures_delta);
 
         self.painter.paint_and_update_textures(
-            self.app.clear_color(&self.egui_ctx.style().visuals),
             clipped_primitives,
             self.egui_ctx.pixels_per_point(),
             &textures_delta,
@@ -389,7 +325,7 @@ impl AppRunner {
     }
 
     fn handle_platform_output(&mut self, platform_output: egui::PlatformOutput) {
-        if self.egui_ctx.options(|o| o.screen_reader) {
+        if self.egui_ctx.options().screen_reader {
             self.screen_reader
                 .speak(&platform_output.events_description());
         }
@@ -401,8 +337,6 @@ impl AppRunner {
             events: _, // already handled
             mutable_text_under_cursor,
             text_cursor_pos,
-            #[cfg(feature = "accesskit")]
-                accesskit_update: _, // not currently implemented
         } = platform_output;
 
         set_cursor_icon(cursor_icon);
@@ -431,60 +365,24 @@ impl AppRunner {
 
 pub type AppRunnerRef = Arc<Mutex<AppRunner>>;
 
-pub struct TargetEvent {
-    target: EventTarget,
-    event_name: String,
-    closure: Closure<dyn FnMut(web_sys::Event)>,
-}
-
-pub struct IntervalHandle {
-    pub handle: i32,
-    pub closure: Closure<dyn FnMut()>,
-}
-
-pub enum EventToUnsubscribe {
-    TargetEvent(TargetEvent),
-    #[allow(dead_code)]
-    IntervalHandle(IntervalHandle),
-}
-
-impl EventToUnsubscribe {
-    pub fn unsubscribe(self) -> Result<(), JsValue> {
-        match self {
-            EventToUnsubscribe::TargetEvent(handle) => {
-                handle.target.remove_event_listener_with_callback(
-                    handle.event_name.as_str(),
-                    handle.closure.as_ref().unchecked_ref(),
-                )?;
-                Ok(())
-            }
-            EventToUnsubscribe::IntervalHandle(handle) => {
-                let window = web_sys::window().unwrap();
-                window.clear_interval_with_handle(handle.handle);
-                Ok(())
-            }
-        }
-    }
-}
-
 pub struct AppRunnerContainer {
     pub runner: AppRunnerRef,
-
     /// Set to `true` if there is a panic.
     /// Used to ignore callbacks after a panic.
     pub panicked: Arc<AtomicBool>,
-    pub events: Vec<EventToUnsubscribe>,
 }
 
 impl AppRunnerContainer {
     /// Convenience function to reduce boilerplate and ensure that all event handlers
     /// are dealt with in the same way
     pub fn add_event_listener<E: wasm_bindgen::JsCast>(
-        &mut self,
+        &self,
         target: &EventTarget,
         event_name: &'static str,
         mut closure: impl FnMut(E, MutexGuard<'_, AppRunner>) + 'static,
     ) -> Result<(), JsValue> {
+        use wasm_bindgen::JsCast;
+
         // Create a JS closure based on the FnMut provided
         let closure = Closure::wrap({
             // Clone atomics
@@ -499,19 +397,14 @@ impl AppRunnerContainer {
 
                     closure(event, runner_ref.lock());
                 }
-            }) as Box<dyn FnMut(web_sys::Event)>
+            }) as Box<dyn FnMut(_)>
         });
 
         // Add the event listener to the target
         target.add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())?;
 
-        let handle = TargetEvent {
+        // Bypass closure drop so that event handler can call the closure
-            target: target.clone(),
+        closure.forget();
-            event_name: event_name.to_owned(),
-            closure,
-        };
-
-        self.events.push(EventToUnsubscribe::TargetEvent(handle));
 
         Ok(())
     }
@@ -521,17 +414,12 @@ impl AppRunnerContainer {
 
 /// Install event listeners to register different input events
 /// and start running the given app.
-pub async fn start(
+pub fn start(
     canvas_id: &str,
     web_options: crate::WebOptions,
     app_creator: epi::AppCreator,
 ) -> Result<AppRunnerRef, JsValue> {
-    #[cfg(not(web_sys_unstable_apis))]
+    let mut runner = AppRunner::new(canvas_id, web_options, app_creator)?;
-    tracing::warn!(
-        "eframe compiled without RUSTFLAGS='--cfg=web_sys_unstable_apis'. Copying text won't work."
-    );
-
-    let mut runner = AppRunner::new(canvas_id, web_options, app_creator).await?;
     runner.warm_up()?;
     start_runner(runner)
 }
@@ -539,26 +427,23 @@ pub async fn start(
 /// Install event listeners to register different input events
 /// and starts running the given [`AppRunner`].
 fn start_runner(app_runner: AppRunner) -> Result<AppRunnerRef, JsValue> {
-    let mut runner_container = AppRunnerContainer {
+    let runner_container = AppRunnerContainer {
         runner: Arc::new(Mutex::new(app_runner)),
         panicked: Arc::new(AtomicBool::new(false)),
-        events: Vec::with_capacity(20),
     };
 
-    super::events::install_canvas_events(&mut runner_container)?;
+    super::events::install_canvas_events(&runner_container)?;
-    super::events::install_document_events(&mut runner_container)?;
+    super::events::install_document_events(&runner_container)?;
-    text_agent::install_text_agent(&mut runner_container)?;
+    text_agent::install_text_agent(&runner_container)?;
 
     super::events::paint_and_schedule(&runner_container.runner, runner_container.panicked.clone())?;
 
     // Disable all event handlers on panic
     let previous_hook = std::panic::take_hook();
-
+    let panicked = runner_container.panicked;
-    runner_container.runner.lock().events_to_unsubscribe = runner_container.events;
-
     std::panic::set_hook(Box::new(move |panic_info| {
         tracing::info!("egui disabled all event handlers due to panic");
-        runner_container.panicked.store(true, SeqCst);
+        panicked.store(true, SeqCst);
 
         // Propagate panic info to the previously registered panic hook
         previous_hook(panic_info);
@@ -576,10 +461,8 @@ impl epi::Storage for LocalStorage {
     fn get_string(&self, key: &str) -> Option<String> {
         local_storage_get(key)
     }
-
     fn set_string(&mut self, key: &str, value: String) {
         local_storage_set(key, &value);
     }
-
     fn flush(&mut self) {}
 }

eframe/src/web/events.rs

@@ -1,21 +1,15 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use egui::Key;
-
 use super::*;
-
+use std::sync::atomic::{AtomicBool, Ordering};
-struct IsDestroyed(pub bool);
 
 pub fn paint_and_schedule(
     runner_ref: &AppRunnerRef,
     panicked: Arc<AtomicBool>,
 ) -> Result<(), JsValue> {
-    fn paint_if_needed(runner_ref: &AppRunnerRef) -> Result<IsDestroyed, JsValue> {
+    fn paint_if_needed(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
         let mut runner_lock = runner_ref.lock();
-        let is_destroyed = runner_lock.is_destroyed.fetch();
+        if runner_lock.needs_repaint.when_to_repaint() <= now_sec() {
-
-        if !is_destroyed && runner_lock.needs_repaint.when_to_repaint() <= now_sec() {
             runner_lock.needs_repaint.clear();
+            runner_lock.clear_color_buffer();
             let (repaint_after, clipped_primitives) = runner_lock.logic()?;
             runner_lock.paint(&clipped_primitives)?;
             runner_lock
@@ -24,13 +18,14 @@ pub fn paint_and_schedule(
             runner_lock.auto_save();
         }
 
-        Ok(IsDestroyed(is_destroyed))
+        Ok(())
     }
 
     fn request_animation_frame(
         runner_ref: AppRunnerRef,
         panicked: Arc<AtomicBool>,
     ) -> Result<(), JsValue> {
+        use wasm_bindgen::JsCast;
         let window = web_sys::window().unwrap();
         let closure = Closure::once(move || paint_and_schedule(&runner_ref, panicked));
         window.request_animation_frame(closure.as_ref().unchecked_ref())?;
@@ -40,16 +35,14 @@ pub fn paint_and_schedule(
 
     // Only paint and schedule if there has been no panic
     if !panicked.load(Ordering::SeqCst) {
-        let is_destroyed = paint_if_needed(runner_ref)?;
+        paint_if_needed(runner_ref)?;
-        if !is_destroyed.0 {
         request_animation_frame(runner_ref.clone(), panicked)?;
     }
-    }
 
     Ok(())
 }
 
-pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+pub fn install_document_events(runner_container: &AppRunnerContainer) -> Result<(), JsValue> {
     let window = web_sys::window().unwrap();
     let document = window.document().unwrap();
 
@@ -66,13 +59,11 @@ pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Res
             runner_lock.input.raw.modifiers = modifiers;
 
             let key = event.key();
-            let egui_key = translate_key(&key);
 
-            if let Some(key) = egui_key {
+            if let Some(key) = translate_key(&key) {
                 runner_lock.input.raw.events.push(egui::Event::Key {
                     key,
                     pressed: true,
-                    repeat: false, // egui will fill this in for us!
                     modifiers,
                 });
             }
@@ -88,18 +79,10 @@ pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Res
 
             let egui_wants_keyboard = runner_lock.egui_ctx().wants_keyboard_input();
 
-            #[allow(clippy::if_same_then_else)]
+            let prevent_default = if matches!(event.key().as_str(), "Tab") {
-            let prevent_default = if egui_key == Some(Key::Tab) {
                 // Always prevent moving cursor to url bar.
                 // egui wants to use tab to move to the next text field.
                 true
-            } else if egui_key == Some(Key::P) {
-                #[allow(clippy::needless_bool)]
-                if modifiers.ctrl || modifiers.command || modifiers.mac_cmd {
-                    true // Prevent ctrl-P opening the print dialog. Users may want to use it for a command palette.
-                } else {
-                    false // let normal P:s through
-                }
             } else if egui_wants_keyboard {
                 matches!(
                     event.key().as_str(),
@@ -123,7 +106,6 @@ pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Res
 
             if prevent_default {
                 event.prevent_default();
-                // event.stop_propagation();
             }
         },
     )?;
@@ -138,7 +120,6 @@ pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Res
                 runner_lock.input.raw.events.push(egui::Event::Key {
                     key,
                     pressed: false,
-                    repeat: false,
                     modifiers,
                 });
             }
@@ -200,40 +181,34 @@ pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Res
         "hashchange",
         |_: web_sys::Event, mut runner_lock| {
             // `epi::Frame::info(&self)` clones `epi::IntegrationInfo`, but we need to modify the original here
-            runner_lock.frame.info.web_info.location.hash = location_hash();
+            if let Some(web_info) = &mut runner_lock.frame.info.web_info {
+                web_info.location.hash = location_hash();
+            }
         },
     )?;
 
     Ok(())
 }
 
-pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+pub fn install_canvas_events(runner_container: &AppRunnerContainer) -> Result<(), JsValue> {
+    use wasm_bindgen::JsCast;
     let canvas = canvas_element(runner_container.runner.lock().canvas_id()).unwrap();
 
-    let prevent_default_events = [
+    {
         // By default, right-clicks open a context menu.
         // We don't want to do that (right clicks is handled by egui):
-        "contextmenu",
+        let event_name = "contextmenu";
-        // Allow users to use ctrl-p for e.g. a command palette
+        let closure = Closure::wrap(Box::new(move |event: web_sys::MouseEvent| {
-        "afterprint",
-    ];
-
-    for event_name in prevent_default_events {
-        let closure =
-            move |event: web_sys::MouseEvent,
-                  mut _runner_lock: egui::mutex::MutexGuard<'_, AppRunner>| {
             event.prevent_default();
-                // event.stop_propagation();
+        }) as Box<dyn FnMut(_)>);
-                // tracing::debug!("Preventing event {:?}", event_name);
+        canvas.add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())?;
-            };
+        closure.forget();
-
-        runner_container.add_event_listener(&canvas, event_name, closure)?;
     }
 
     runner_container.add_event_listener(
         &canvas,
         "mousedown",
-        |event: web_sys::MouseEvent, mut runner_lock: egui::mutex::MutexGuard<'_, AppRunner>| {
+        |event: web_sys::MouseEvent, mut runner_lock| {
             if let Some(button) = button_from_mouse_event(&event) {
                 let pos = pos_from_mouse_event(runner_lock.canvas_id(), &event);
                 let modifiers = runner_lock.input.raw.modifiers;
@@ -328,7 +303,7 @@ pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Resul
                     modifiers,
                 });
 
-            push_touches(&mut runner_lock, egui::TouchPhase::Start, &event);
+            push_touches(&mut *runner_lock, egui::TouchPhase::Start, &event);
             runner_lock.needs_repaint.repaint_asap();
             event.stop_propagation();
             event.prevent_default();
@@ -350,7 +325,7 @@ pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Resul
                 .events
                 .push(egui::Event::PointerMoved(pos));
 
-            push_touches(&mut runner_lock, egui::TouchPhase::Move, &event);
+            push_touches(&mut *runner_lock, egui::TouchPhase::Move, &event);
             runner_lock.needs_repaint.repaint_asap();
             event.stop_propagation();
             event.prevent_default();
@@ -377,7 +352,7 @@ pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Resul
                 // Then remove hover effect:
                 runner_lock.input.raw.events.push(egui::Event::PointerGone);
 
-                push_touches(&mut runner_lock, egui::TouchPhase::End, &event);
+                push_touches(&mut *runner_lock, egui::TouchPhase::End, &event);
                 runner_lock.needs_repaint.repaint_asap();
                 event.stop_propagation();
                 event.prevent_default();
@@ -408,7 +383,7 @@ pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Resul
                 }
                 web_sys::WheelEvent::DOM_DELTA_LINE => {
                     #[allow(clippy::let_and_return)]
-                    let points_per_scroll_line = 8.0; // Note that this is intentionally different from what we use in winit.
+                    let points_per_scroll_line = 8.0; // Note that this is intentionally different from what we use in egui_glium / winit.
                     points_per_scroll_line
                 }
                 _ => 1.0, // DOM_DELTA_PIXEL

eframe/src/web/glow_wrapping.rs

@@ -0,0 +1,158 @@
+use egui::{ClippedPrimitive, Rgba};
+use egui_glow::glow;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use web_sys::HtmlCanvasElement;
+#[cfg(not(target_arch = "wasm32"))]
+use web_sys::{WebGl2RenderingContext, WebGlRenderingContext};
+
+pub(crate) struct WrappedGlowPainter {
+    pub(crate) canvas: HtmlCanvasElement,
+    pub(crate) canvas_id: String,
+    pub(crate) painter: egui_glow::Painter,
+}
+
+impl WrappedGlowPainter {
+    pub fn new(canvas_id: &str) -> Result<Self, String> {
+        let canvas = super::canvas_element_or_die(canvas_id);
+
+        let (gl, shader_prefix) = init_glow_context_from_canvas(&canvas)?;
+        let gl = std::sync::Arc::new(gl);
+
+        let dimension = [canvas.width() as i32, canvas.height() as i32];
+        let painter = egui_glow::Painter::new(gl, Some(dimension), shader_prefix)
+            .map_err(|error| format!("Error starting glow painter: {}", error))?;
+
+        Ok(Self {
+            canvas,
+            canvas_id: canvas_id.to_owned(),
+            painter,
+        })
+    }
+}
+
+impl WrappedGlowPainter {
+    pub fn gl(&self) -> &std::sync::Arc<glow::Context> {
+        self.painter.gl()
+    }
+
+    pub fn max_texture_side(&self) -> usize {
+        self.painter.max_texture_side()
+    }
+
+    pub fn canvas_id(&self) -> &str {
+        &self.canvas_id
+    }
+
+    pub fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta) {
+        self.painter.set_texture(tex_id, delta);
+    }
+
+    pub fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.painter.free_texture(tex_id);
+    }
+
+    pub fn clear(&self, clear_color: Rgba) {
+        let canvas_dimension = [self.canvas.width(), self.canvas.height()];
+        egui_glow::painter::clear(self.painter.gl(), canvas_dimension, clear_color);
+    }
+
+    pub fn paint_primitives(
+        &mut self,
+        clipped_primitives: &[ClippedPrimitive],
+        pixels_per_point: f32,
+    ) -> Result<(), JsValue> {
+        let canvas_dimension = [self.canvas.width(), self.canvas.height()];
+        self.painter
+            .paint_primitives(canvas_dimension, pixels_per_point, clipped_primitives);
+        Ok(())
+    }
+
+    pub fn paint_and_update_textures(
+        &mut self,
+        clipped_primitives: &[egui::ClippedPrimitive],
+        pixels_per_point: f32,
+        textures_delta: &egui::TexturesDelta,
+    ) -> Result<(), JsValue> {
+        for (id, image_delta) in &textures_delta.set {
+            self.set_texture(*id, image_delta);
+        }
+
+        self.paint_primitives(clipped_primitives, pixels_per_point)?;
+
+        for &id in &textures_delta.free {
+            self.free_texture(id);
+        }
+
+        Ok(())
+    }
+}
+
+/// Returns glow context and shader prefix.
+fn init_glow_context_from_canvas(
+    canvas: &HtmlCanvasElement,
+) -> Result<(glow::Context, &'static str), String> {
+    const BEST_FIRST: bool = true;
+
+    let result = if BEST_FIRST {
+        // Trying WebGl2 first
+        init_webgl2(canvas).or_else(|| init_webgl1(canvas))
+    } else {
+        // Trying WebGl1 first (useful for testing).
+        tracing::warn!("Looking for WebGL1 first");
+        init_webgl1(canvas).or_else(|| init_webgl2(canvas))
+    };
+
+    if let Some(result) = result {
+        Ok(result)
+    } else {
+        Err("WebGL isn't supported".into())
+    }
+}
+
+fn init_webgl1(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
+    let gl1_ctx = canvas
+        .get_context("webgl")
+        .expect("Failed to query about WebGL2 context");
+
+    let gl1_ctx = gl1_ctx?;
+    tracing::debug!("WebGL1 selected.");
+
+    let gl1_ctx = gl1_ctx
+        .dyn_into::<web_sys::WebGlRenderingContext>()
+        .unwrap();
+
+    let shader_prefix = if super::webgl1_requires_brightening(&gl1_ctx) {
+        tracing::debug!("Enabling webkitGTK brightening workaround.");
+        "#define APPLY_BRIGHTENING_GAMMA"
+    } else {
+        ""
+    };
+
+    let gl = glow::Context::from_webgl1_context(gl1_ctx);
+
+    Some((gl, shader_prefix))
+}
+
+fn init_webgl2(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
+    let gl2_ctx = canvas
+        .get_context("webgl2")
+        .expect("Failed to query about WebGL2 context");
+
+    let gl2_ctx = gl2_ctx?;
+    tracing::debug!("WebGL2 selected.");
+
+    let gl2_ctx = gl2_ctx
+        .dyn_into::<web_sys::WebGl2RenderingContext>()
+        .unwrap();
+    let gl = glow::Context::from_webgl2_context(gl2_ctx);
+    let shader_prefix = "";
+
+    Some((gl, shader_prefix))
+}
+
+trait DummyWebGLConstructor {
+    fn from_webgl1_context(context: web_sys::WebGlRenderingContext) -> Self;
+
+    fn from_webgl2_context(context: web_sys::WebGl2RenderingContext) -> Self;
+}

eframe/src/web/input.rs

@@ -54,8 +54,8 @@ pub fn pos_from_touch_event(
 
 fn pos_from_touch(canvas_origin: egui::Pos2, touch: &web_sys::Touch) -> egui::Pos2 {
     egui::Pos2 {
-        x: touch.page_x() as f32 - canvas_origin.x,
+        x: touch.page_x() as f32 - canvas_origin.x as f32,
-        y: touch.page_y() as f32 - canvas_origin.y,
+        y: touch.page_y() as f32 - canvas_origin.y as f32,
     }
 }
 
@@ -113,88 +113,83 @@ pub fn should_ignore_key(key: &str) -> bool {
 /// Web sends all all keys as strings, so it is up to us to figure out if it is
 /// a real text input or the name of a key.
 pub fn translate_key(key: &str) -> Option<egui::Key> {
-    use egui::Key;
-
     match key {
-        "ArrowDown" => Some(Key::ArrowDown),
+        "ArrowDown" => Some(egui::Key::ArrowDown),
-        "ArrowLeft" => Some(Key::ArrowLeft),
+        "ArrowLeft" => Some(egui::Key::ArrowLeft),
-        "ArrowRight" => Some(Key::ArrowRight),
+        "ArrowRight" => Some(egui::Key::ArrowRight),
-        "ArrowUp" => Some(Key::ArrowUp),
+        "ArrowUp" => Some(egui::Key::ArrowUp),
 
-        "Esc" | "Escape" => Some(Key::Escape),
+        "Esc" | "Escape" => Some(egui::Key::Escape),
-        "Tab" => Some(Key::Tab),
+        "Tab" => Some(egui::Key::Tab),
-        "Backspace" => Some(Key::Backspace),
+        "Backspace" => Some(egui::Key::Backspace),
-        "Enter" => Some(Key::Enter),
+        "Enter" => Some(egui::Key::Enter),
-        "Space" | " " => Some(Key::Space),
+        "Space" | " " => Some(egui::Key::Space),
 
-        "Help" | "Insert" => Some(Key::Insert),
+        "Help" | "Insert" => Some(egui::Key::Insert),
-        "Delete" => Some(Key::Delete),
+        "Delete" => Some(egui::Key::Delete),
-        "Home" => Some(Key::Home),
+        "Home" => Some(egui::Key::Home),
-        "End" => Some(Key::End),
+        "End" => Some(egui::Key::End),
-        "PageUp" => Some(Key::PageUp),
+        "PageUp" => Some(egui::Key::PageUp),
-        "PageDown" => Some(Key::PageDown),
+        "PageDown" => Some(egui::Key::PageDown),
 
-        "-" => Some(Key::Minus),
+        "0" => Some(egui::Key::Num0),
-        "+" | "=" => Some(Key::PlusEquals),
+        "1" => Some(egui::Key::Num1),
+        "2" => Some(egui::Key::Num2),
+        "3" => Some(egui::Key::Num3),
+        "4" => Some(egui::Key::Num4),
+        "5" => Some(egui::Key::Num5),
+        "6" => Some(egui::Key::Num6),
+        "7" => Some(egui::Key::Num7),
+        "8" => Some(egui::Key::Num8),
+        "9" => Some(egui::Key::Num9),
 
-        "0" => Some(Key::Num0),
+        "a" | "A" => Some(egui::Key::A),
-        "1" => Some(Key::Num1),
+        "b" | "B" => Some(egui::Key::B),
-        "2" => Some(Key::Num2),
+        "c" | "C" => Some(egui::Key::C),
-        "3" => Some(Key::Num3),
+        "d" | "D" => Some(egui::Key::D),
-        "4" => Some(Key::Num4),
+        "e" | "E" => Some(egui::Key::E),
-        "5" => Some(Key::Num5),
+        "f" | "F" => Some(egui::Key::F),
-        "6" => Some(Key::Num6),
+        "g" | "G" => Some(egui::Key::G),
-        "7" => Some(Key::Num7),
+        "h" | "H" => Some(egui::Key::H),
-        "8" => Some(Key::Num8),
+        "i" | "I" => Some(egui::Key::I),
-        "9" => Some(Key::Num9),
+        "j" | "J" => Some(egui::Key::J),
+        "k" | "K" => Some(egui::Key::K),
+        "l" | "L" => Some(egui::Key::L),
+        "m" | "M" => Some(egui::Key::M),
+        "n" | "N" => Some(egui::Key::N),
+        "o" | "O" => Some(egui::Key::O),
+        "p" | "P" => Some(egui::Key::P),
+        "q" | "Q" => Some(egui::Key::Q),
+        "r" | "R" => Some(egui::Key::R),
+        "s" | "S" => Some(egui::Key::S),
+        "t" | "T" => Some(egui::Key::T),
+        "u" | "U" => Some(egui::Key::U),
+        "v" | "V" => Some(egui::Key::V),
+        "w" | "W" => Some(egui::Key::W),
+        "x" | "X" => Some(egui::Key::X),
+        "y" | "Y" => Some(egui::Key::Y),
+        "z" | "Z" => Some(egui::Key::Z),
 
-        "a" | "A" => Some(Key::A),
+        "F1" => Some(egui::Key::F1),
-        "b" | "B" => Some(Key::B),
+        "F2" => Some(egui::Key::F2),
-        "c" | "C" => Some(Key::C),
+        "F3" => Some(egui::Key::F3),
-        "d" | "D" => Some(Key::D),
+        "F4" => Some(egui::Key::F4),
-        "e" | "E" => Some(Key::E),
+        "F5" => Some(egui::Key::F5),
-        "f" | "F" => Some(Key::F),
+        "F6" => Some(egui::Key::F6),
-        "g" | "G" => Some(Key::G),
+        "F7" => Some(egui::Key::F7),
-        "h" | "H" => Some(Key::H),
+        "F8" => Some(egui::Key::F8),
-        "i" | "I" => Some(Key::I),
+        "F9" => Some(egui::Key::F9),
-        "j" | "J" => Some(Key::J),
+        "F10" => Some(egui::Key::F10),
-        "k" | "K" => Some(Key::K),
+        "F11" => Some(egui::Key::F11),
-        "l" | "L" => Some(Key::L),
+        "F12" => Some(egui::Key::F12),
-        "m" | "M" => Some(Key::M),
+        "F13" => Some(egui::Key::F13),
-        "n" | "N" => Some(Key::N),
+        "F14" => Some(egui::Key::F14),
-        "o" | "O" => Some(Key::O),
+        "F15" => Some(egui::Key::F15),
-        "p" | "P" => Some(Key::P),
+        "F16" => Some(egui::Key::F16),
-        "q" | "Q" => Some(Key::Q),
+        "F17" => Some(egui::Key::F17),
-        "r" | "R" => Some(Key::R),
+        "F18" => Some(egui::Key::F18),
-        "s" | "S" => Some(Key::S),
+        "F19" => Some(egui::Key::F19),
-        "t" | "T" => Some(Key::T),
+        "F20" => Some(egui::Key::F20),
-        "u" | "U" => Some(Key::U),
-        "v" | "V" => Some(Key::V),
-        "w" | "W" => Some(Key::W),
-        "x" | "X" => Some(Key::X),
-        "y" | "Y" => Some(Key::Y),
-        "z" | "Z" => Some(Key::Z),
-
-        "F1" => Some(Key::F1),
-        "F2" => Some(Key::F2),
-        "F3" => Some(Key::F3),
-        "F4" => Some(Key::F4),
-        "F5" => Some(Key::F5),
-        "F6" => Some(Key::F6),
-        "F7" => Some(Key::F7),
-        "F8" => Some(Key::F8),
-        "F9" => Some(Key::F9),
-        "F10" => Some(Key::F10),
-        "F11" => Some(Key::F11),
-        "F12" => Some(Key::F12),
-        "F13" => Some(Key::F13),
-        "F14" => Some(Key::F14),
-        "F15" => Some(Key::F15),
-        "F16" => Some(Key::F16),
-        "F17" => Some(Key::F17),
-        "F18" => Some(Key::F18),
-        "F19" => Some(Key::F19),
-        "F20" => Some(Key::F20),
 
         _ => None,
     }

eframe/src/web/mod.rs

@@ -4,26 +4,12 @@
 
 pub mod backend;
 mod events;
+mod glow_wrapping;
 mod input;
 pub mod screen_reader;
 pub mod storage;
 mod text_agent;
 
-#[cfg(not(any(feature = "glow", feature = "wgpu")))]
-compile_error!("You must enable either the 'glow' or 'wgpu' feature");
-
-mod web_painter;
-
-#[cfg(feature = "glow")]
-mod web_painter_glow;
-#[cfg(feature = "glow")]
-pub(crate) type ActiveWebPainter = web_painter_glow::WebPainterGlow;
-
-#[cfg(feature = "wgpu")]
-mod web_painter_wgpu;
-#[cfg(all(feature = "wgpu", not(feature = "glow")))]
-pub(crate) type ActiveWebPainter = web_painter_wgpu::WebPainterWgpu;
-
 pub use backend::*;
 pub use events::*;
 pub use storage::*;
@@ -34,7 +20,6 @@ use std::sync::{
     Arc,
 };
 
-use egui::Vec2;
 use wasm_bindgen::prelude::*;
 use web_sys::EventTarget;
 
@@ -56,7 +41,6 @@ pub fn now_sec() -> f64 {
         / 1000.0
 }
 
-#[allow(dead_code)]
 pub fn screen_size_in_native_points() -> Option<egui::Vec2> {
     let window = web_sys::window()?;
     Some(egui::vec2(
@@ -83,6 +67,7 @@ pub fn system_theme() -> Option<Theme> {
 }
 
 pub fn canvas_element(canvas_id: &str) -> Option<web_sys::HtmlCanvasElement> {
+    use wasm_bindgen::JsCast;
     let document = web_sys::window()?.document()?;
     let canvas = document.get_element_by_id(canvas_id)?;
     canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok()
@@ -90,14 +75,14 @@ pub fn canvas_element(canvas_id: &str) -> Option<web_sys::HtmlCanvasElement> {
 
 pub fn canvas_element_or_die(canvas_id: &str) -> web_sys::HtmlCanvasElement {
     canvas_element(canvas_id)
-        .unwrap_or_else(|| panic!("Failed to find canvas with id {:?}", canvas_id))
+        .unwrap_or_else(|| panic!("Failed to find canvas with id '{}'", canvas_id))
 }
 
 fn canvas_origin(canvas_id: &str) -> egui::Pos2 {
     let rect = canvas_element(canvas_id)
         .unwrap()
         .get_bounding_client_rect();
-    egui::pos2(rect.left() as f32, rect.top() as f32)
+    egui::Pos2::new(rect.left() as f32, rect.top() as f32)
 }
 
 pub fn canvas_size_in_points(canvas_id: &str) -> egui::Vec2 {
@@ -111,25 +96,13 @@ pub fn canvas_size_in_points(canvas_id: &str) -> egui::Vec2 {
 
 pub fn resize_canvas_to_screen_size(canvas_id: &str, max_size_points: egui::Vec2) -> Option<()> {
     let canvas = canvas_element(canvas_id)?;
-    let parent = canvas.parent_element()?;
-
-    let width = parent.scroll_width();
-    let height = parent.scroll_height();
-
-    let canvas_real_size = Vec2 {
-        x: width as f32,
-        y: height as f32,
-    };
-
-    if width <= 0 || height <= 0 {
-        tracing::error!("egui canvas parent size is {}x{}. Try adding `html, body {{ height: 100%; width: 100% }}` to your CSS!", width, height);
-    }
 
+    let screen_size_points = screen_size_in_native_points()?;
     let pixels_per_point = native_pixels_per_point();
 
     let max_size_pixels = pixels_per_point * max_size_points;
 
-    let canvas_size_pixels = pixels_per_point * canvas_real_size;
+    let canvas_size_pixels = pixels_per_point * screen_size_points;
     let canvas_size_pixels = canvas_size_pixels.min(max_size_pixels);
     let canvas_size_points = canvas_size_pixels / pixels_per_point;
 
@@ -256,3 +229,47 @@ pub fn percent_decode(s: &str) -> String {
         .decode_utf8_lossy()
         .to_string()
 }
+
+// ----------------------------------------------------------------------------
+
+pub(crate) fn webgl1_requires_brightening(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // See https://github.com/emilk/egui/issues/794
+
+    // detect WebKitGTK
+
+    // WebKitGTK use WebKit default unmasked vendor and renderer
+    // but safari use same vendor and renderer
+    // so exclude "Mac OS X" user-agent.
+    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
+    !user_agent.contains("Mac OS X") && is_safari_and_webkit_gtk(gl)
+}
+
+/// detecting Safari and `webkitGTK`.
+///
+/// Safari and `webkitGTK` use unmasked renderer :Apple GPU
+///
+/// If we detect safari or `webkitGTKs` returns true.
+///
+/// This function used to avoid displaying linear color with `sRGB` supported systems.
+fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // This call produces a warning in Firefox ("WEBGL_debug_renderer_info is deprecated in Firefox and will be removed.")
+    // but unless we call it we get errors in Chrome when we call `get_parameter` below.
+    // TODO(emilk): do something smart based on user agent?
+    if gl
+        .get_extension("WEBGL_debug_renderer_info")
+        .unwrap()
+        .is_some()
+    {
+        if let Ok(renderer) =
+            gl.get_parameter(web_sys::WebglDebugRendererInfo::UNMASKED_RENDERER_WEBGL)
+        {
+            if let Some(renderer) = renderer.as_string() {
+                if renderer.contains("Apple") {
+                    return true;
+                }
+            }
+        }
+    }
+
+    false
+}

eframe/src/web/screen_reader.rs

@@ -1,9 +1,9 @@
 pub struct ScreenReader {
-    #[cfg(feature = "tts")]
+    #[cfg(feature = "screen_reader")]
     tts: Option<tts::Tts>,
 }
 
-#[cfg(not(feature = "tts"))]
+#[cfg(not(feature = "screen_reader"))]
 #[allow(clippy::derivable_impls)] // False positive
 impl Default for ScreenReader {
     fn default() -> Self {
@@ -11,7 +11,7 @@ impl Default for ScreenReader {
     }
 }
 
-#[cfg(feature = "tts")]
+#[cfg(feature = "screen_reader")]
 impl Default for ScreenReader {
     fn default() -> Self {
         let tts = match tts::Tts::default() {
@@ -29,11 +29,11 @@ impl Default for ScreenReader {
 }
 
 impl ScreenReader {
-    #[cfg(not(feature = "tts"))]
+    #[cfg(not(feature = "screen_reader"))]
     #[allow(clippy::unused_self)]
     pub fn speak(&mut self, _text: &str) {}
 
-    #[cfg(feature = "tts")]
+    #[cfg(feature = "screen_reader")]
     pub fn speak(&mut self, text: &str) {
         if text.is_empty() {
             return;

eframe/src/web/storage.rs

@@ -15,7 +15,7 @@ pub fn load_memory(ctx: &egui::Context) {
     if let Some(memory_string) = local_storage_get("egui_memory_ron") {
         match ron::from_str(&memory_string) {
             Ok(memory) => {
-                ctx.memory_mut(|m| *m = memory);
+                *ctx.memory() = memory;
             }
             Err(err) => {
                 tracing::error!("Failed to parse memory RON: {}", err);
@@ -29,7 +29,7 @@ pub fn load_memory(_: &egui::Context) {}
 
 #[cfg(feature = "persistence")]
 pub fn save_memory(ctx: &egui::Context) {
-    match ctx.memory(|mem| ron::to_string(mem)) {
+    match ron::to_string(&*ctx.memory()) {
         Ok(ron) => {
             local_storage_set("egui_memory_ron", &ron);
         }

eframe/src/web/text_agent.rs

@@ -10,6 +10,7 @@ use wasm_bindgen::prelude::*;
 static AGENT_ID: &str = "egui_text_agent";
 
 pub fn text_agent() -> web_sys::HtmlInputElement {
+    use wasm_bindgen::JsCast;
     web_sys::window()
         .unwrap()
         .document()
@@ -21,7 +22,8 @@ pub fn text_agent() -> web_sys::HtmlInputElement {
 }
 
 /// Text event handler,
-pub fn install_text_agent(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+pub fn install_text_agent(runner_container: &AppRunnerContainer) -> Result<(), JsValue> {
+    use wasm_bindgen::JsCast;
     let window = web_sys::window().unwrap();
     let document = window.document().unwrap();
     let body = document.body().expect("document should have a body");
@@ -127,6 +129,7 @@ pub fn install_text_agent(runner_container: &mut AppRunnerContainer) -> Result<(
 
 /// Focus or blur text agent to toggle mobile keyboard.
 pub fn update_text_agent(runner: MutexGuard<'_, AppRunner>) -> Option<()> {
+    use wasm_bindgen::JsCast;
     use web_sys::HtmlInputElement;
     let window = web_sys::window()?;
     let document = window.document()?;

egui-wgpu/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog for egui-wgpu
+All notable changes to the `egui-wgpu` integration will be noted in this file.
+
+
+## Unreleased
+Enables deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634))
+
+## 0.18.0 - 2022-05-15
+First published version since moving the code into the `egui` repository from <https://github.com/LU15W1R7H/eww>.

egui-wgpu/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "egui-wgpu"
+version = "0.18.0"
+description = "Bindings for using egui natively using the wgpu library"
+authors = [
+    "Nils Hasenbanck <nils@hasenbanck.de>",
+    "embotech <opensource@embotech.com>",
+    "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
+]
+edition = "2021"
+rust-version = "1.60"
+homepage = "https://github.com/emilk/egui/tree/master/egui-wgpu"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/egui-wgpu"
+categories = ["gui", "game-development"]
+keywords = ["wgpu", "egui", "gui", "gamedev"]
+include = [
+  "../LICENSE-APACHE",
+  "../LICENSE-MIT",
+  "**/*.rs",
+  "**/*.wgsl",
+  "Cargo.toml",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+
+
+[features]
+## Enable [`winit`](https://docs.rs/winit) integration.
+winit = ["dep:pollster", "dep:winit"]
+
+
+[dependencies]
+egui = { version = "0.18.1", path = "../egui", default-features = false, features = [
+    "bytemuck",
+] }
+
+bytemuck = "1.7"
+tracing = "0.1"
+type-map = "0.5.0"
+wgpu = "0.13"
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+pollster = { version = "0.2", optional = true }
+winit = { version = "0.26", optional = true }

egui-wgpu/src/egui.wgsl

@@ -0,0 +1,80 @@
+// Vertex shader bindings
+
+struct VertexOutput {
+    @location(0) tex_coord: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @builtin(position) position: vec4<f32>,
+};
+
+struct Locals {
+    screen_size: vec2<f32>,
+    // Uniform buffers need to be at least 16 bytes in WebGL.
+    // See https://github.com/gfx-rs/wgpu/issues/2072
+    _padding: vec2<u32>,
+};
+@group(0) @binding(0) var<uniform> r_locals: Locals;
+
+// 0-1 from 0-255
+fn linear_from_srgb(srgb: vec3<f32>) -> vec3<f32> {
+    let cutoff = srgb < vec3<f32>(10.31475);
+    let lower = srgb / vec3<f32>(3294.6);
+    let higher = pow((srgb + vec3<f32>(14.025)) / vec3<f32>(269.025), vec3<f32>(2.4));
+    return select(higher, lower, cutoff);
+}
+
+// [u8; 4] SRGB as u32 -> [r, g, b, a]
+fn unpack_color(color: u32) -> vec4<f32> {
+    return vec4<f32>(
+        f32(color & 255u),
+        f32((color >> 8u) & 255u),
+        f32((color >> 16u) & 255u),
+        f32((color >> 24u) & 255u),
+    );
+}
+
+fn position_from_screen(screen_pos: vec2<f32>) -> vec4<f32> {
+    return vec4<f32>(
+        2.0 * screen_pos.x / r_locals.screen_size.x - 1.0,
+        1.0 - 2.0 * screen_pos.y / r_locals.screen_size.y,
+        0.0,
+        1.0,
+    );
+}
+
+@vertex
+fn vs_main(
+    @location(0) a_pos: vec2<f32>,
+    @location(1) a_tex_coord: vec2<f32>,
+    @location(2) a_color: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.tex_coord = a_tex_coord;
+    let color = unpack_color(a_color);
+    out.color = vec4<f32>(linear_from_srgb(color.rgb), color.a / 255.0);
+    out.position = position_from_screen(a_pos);
+    return out;
+}
+
+@vertex
+fn vs_conv_main(
+    @location(0) a_pos: vec2<f32>,
+    @location(1) a_tex_coord: vec2<f32>,
+    @location(2) a_color: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.tex_coord = a_tex_coord;
+    let color = unpack_color(a_color);
+    out.color = vec4<f32>(color.rgba / 255.0);
+    out.position = position_from_screen(a_pos);
+    return out;
+}
+
+// Fragment shader bindings
+
+@group(1) @binding(0) var r_tex_color: texture_2d<f32>;
+@group(1) @binding(1) var r_tex_sampler: sampler;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return in.color * textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
+}

egui-wgpu/src/lib.rs

@@ -0,0 +1,19 @@
+//! This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [wgpu](https://crates.io/crates/wgpu).
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(unsafe_code)]
+
+pub use wgpu;
+
+/// Low-level painting of [`egui`] on [`wgpu`].
+pub mod renderer;
+pub use renderer::CallbackFn;
+
+/// Module for painting [`egui`] with [`wgpu`] on [`winit`].
+#[cfg(feature = "winit")]
+pub mod winit;
+#[cfg(feature = "winit")]
+pub use crate::winit::RenderState;

egui-wgpu/src/renderer.rs

@@ -0,0 +1,823 @@
+#![allow(unsafe_code)]
+
+use std::{borrow::Cow, collections::HashMap, num::NonZeroU32};
+
+use egui::{epaint::Primitive, PaintCallbackInfo};
+use type_map::TypeMap;
+use wgpu;
+use wgpu::util::DeviceExt as _;
+
+/// A callback function that can be used to compose an [`egui::PaintCallback`] for custom WGPU
+/// rendering.
+///
+/// The callback is composed of two functions: `prepare` and `paint`.
+///
+/// `prepare` is called every frame before `paint`, and can use the passed-in [`wgpu::Device`] and
+/// [`wgpu::Buffer`] to allocate or modify GPU resources such as buffers.
+///
+/// `paint` is called after `prepare` and is given access to the the [`wgpu::RenderPass`] so that it
+/// can issue draw commands.
+///
+/// The final argument of both the `prepare` and `paint` callbacks is a the
+/// [`paint_callback_resources`][crate::renderer::RenderPass::paint_callback_resources].
+/// `paint_callback_resources` has the same lifetime as the Egui render pass, so it can be used to
+/// store buffers, pipelines, and other information that needs to be accessed during the render
+/// pass.
+///
+/// # Example
+///
+/// See the [`custom3d_glow`](https://github.com/emilk/egui/blob/master/egui_demo_app/src/apps/custom3d_wgpu.rs) demo source for a detailed usage example.
+pub struct CallbackFn {
+    prepare: Box<PrepareCallback>,
+    paint: Box<PaintCallback>,
+}
+
+type PrepareCallback = dyn Fn(&wgpu::Device, &wgpu::Queue, &mut TypeMap) + Sync + Send;
+type PaintCallback =
+    dyn for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap) + Sync + Send;
+
+impl Default for CallbackFn {
+    fn default() -> Self {
+        CallbackFn {
+            prepare: Box::new(|_, _, _| ()),
+            paint: Box::new(|_, _, _| ()),
+        }
+    }
+}
+
+impl CallbackFn {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the prepare callback
+    pub fn prepare<F>(mut self, prepare: F) -> Self
+    where
+        F: Fn(&wgpu::Device, &wgpu::Queue, &mut TypeMap) + Sync + Send + 'static,
+    {
+        self.prepare = Box::new(prepare) as _;
+        self
+    }
+
+    /// Set the paint callback
+    pub fn paint<F>(mut self, paint: F) -> Self
+    where
+        F: for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap)
+            + Sync
+            + Send
+            + 'static,
+    {
+        self.paint = Box::new(paint) as _;
+        self
+    }
+}
+
+/// Enum for selecting the right buffer type.
+#[derive(Debug)]
+enum BufferType {
+    Uniform,
+    Index,
+    Vertex,
+}
+
+/// Information about the screen used for rendering.
+pub struct ScreenDescriptor {
+    /// Size of the window in physical pixels.
+    pub size_in_pixels: [u32; 2],
+
+    /// HiDPI scale factor (pixels per point).
+    pub pixels_per_point: f32,
+}
+
+impl ScreenDescriptor {
+    /// size in "logical" points
+    fn screen_size_in_points(&self) -> [f32; 2] {
+        [
+            self.size_in_pixels[0] as f32 / self.pixels_per_point,
+            self.size_in_pixels[1] as f32 / self.pixels_per_point,
+        ]
+    }
+}
+
+/// Uniform buffer used when rendering.
+#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+#[repr(C)]
+struct UniformBuffer {
+    screen_size_in_points: [f32; 2],
+    // Uniform buffers need to be at least 16 bytes in WebGL.
+    // See https://github.com/gfx-rs/wgpu/issues/2072
+    _padding: [u32; 2],
+}
+
+/// Wraps the buffers and includes additional information.
+#[derive(Debug)]
+struct SizedBuffer {
+    buffer: wgpu::Buffer,
+    /// number of bytes
+    size: usize,
+}
+
+/// Render pass to render a egui based GUI.
+pub struct RenderPass {
+    render_pipeline: wgpu::RenderPipeline,
+    index_buffers: Vec<SizedBuffer>,
+    vertex_buffers: Vec<SizedBuffer>,
+    uniform_buffer: SizedBuffer,
+    uniform_bind_group: wgpu::BindGroup,
+    texture_bind_group_layout: wgpu::BindGroupLayout,
+    /// Map of egui texture IDs to textures and their associated bindgroups (texture view +
+    /// sampler). The texture may be None if the TextureId is just a handle to a user-provided
+    /// sampler.
+    textures: HashMap<egui::TextureId, (Option<wgpu::Texture>, wgpu::BindGroup)>,
+    next_user_texture_id: u64,
+    /// Storage for use by [`egui::PaintCallback`]'s that need to store resources such as render
+    /// pipelines that must have the lifetime of the renderpass.
+    pub paint_callback_resources: type_map::TypeMap,
+}
+
+impl RenderPass {
+    /// Creates a new render pass to render a egui UI.
+    ///
+    /// If the format passed is not a *Srgb format, the shader will automatically convert to `sRGB` colors in the shader.
+    pub fn new(
+        device: &wgpu::Device,
+        output_format: wgpu::TextureFormat,
+        msaa_samples: u32,
+    ) -> Self {
+        let shader = wgpu::ShaderModuleDescriptor {
+            label: Some("egui_shader"),
+            source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("egui.wgsl"))),
+        };
+        let module = device.create_shader_module(shader);
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("egui_uniform_buffer"),
+            contents: bytemuck::cast_slice(&[UniformBuffer {
+                screen_size_in_points: [0.0, 0.0],
+                _padding: Default::default(),
+            }]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+        let uniform_buffer = SizedBuffer {
+            buffer: uniform_buffer,
+            size: std::mem::size_of::<UniformBuffer>(),
+        };
+
+        let uniform_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("egui_uniform_bind_group_layout"),
+                entries: &[wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::VERTEX,
+                    ty: wgpu::BindingType::Buffer {
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                        ty: wgpu::BufferBindingType::Uniform,
+                    },
+                    count: None,
+                }],
+            });
+
+        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("egui_uniform_bind_group"),
+            layout: &uniform_bind_group_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &uniform_buffer.buffer,
+                    offset: 0,
+                    size: None,
+                }),
+            }],
+        });
+
+        let texture_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("egui_texture_bind_group_layout"),
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                        count: None,
+                    },
+                ],
+            });
+
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("egui_pipeline_layout"),
+            bind_group_layouts: &[&uniform_bind_group_layout, &texture_bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("egui_pipeline"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                entry_point: if output_format.describe().srgb {
+                    "vs_main"
+                } else {
+                    "vs_conv_main"
+                },
+                module: &module,
+                buffers: &[wgpu::VertexBufferLayout {
+                    array_stride: 5 * 4,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    // 0: vec2 position
+                    // 1: vec2 texture coordinates
+                    // 2: uint color
+                    attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2, 2 => Uint32],
+                }],
+            },
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                unclipped_depth: false,
+                conservative: false,
+                cull_mode: None,
+                front_face: wgpu::FrontFace::default(),
+                polygon_mode: wgpu::PolygonMode::default(),
+                strip_index_format: None,
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState {
+                alpha_to_coverage_enabled: false,
+                count: msaa_samples,
+                mask: !0,
+            },
+
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: output_format,
+                    blend: Some(wgpu::BlendState {
+                        color: wgpu::BlendComponent {
+                            src_factor: wgpu::BlendFactor::One,
+                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                            operation: wgpu::BlendOperation::Add,
+                        },
+                        alpha: wgpu::BlendComponent {
+                            src_factor: wgpu::BlendFactor::OneMinusDstAlpha,
+                            dst_factor: wgpu::BlendFactor::One,
+                            operation: wgpu::BlendOperation::Add,
+                        },
+                    }),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview: None,
+        });
+
+        Self {
+            render_pipeline,
+            vertex_buffers: Vec::with_capacity(64),
+            index_buffers: Vec::with_capacity(64),
+            uniform_buffer,
+            uniform_bind_group,
+            texture_bind_group_layout,
+            textures: HashMap::new(),
+            next_user_texture_id: 0,
+            paint_callback_resources: TypeMap::default(),
+        }
+    }
+
+    /// Executes the egui render pass.
+    pub fn execute(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        color_attachment: &wgpu::TextureView,
+        paint_jobs: &[egui::epaint::ClippedPrimitive],
+        screen_descriptor: &ScreenDescriptor,
+        clear_color: Option<wgpu::Color>,
+    ) {
+        let load_operation = if let Some(color) = clear_color {
+            wgpu::LoadOp::Clear(color)
+        } else {
+            wgpu::LoadOp::Load
+        };
+
+        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: color_attachment,
+                resolve_target: None,
+                ops: wgpu::Operations {
+                    load: load_operation,
+                    store: true,
+                },
+            })],
+            depth_stencil_attachment: None,
+            label: Some("egui main render pass"),
+        });
+        rpass.push_debug_group("egui_pass");
+
+        self.execute_with_renderpass(&mut rpass, paint_jobs, screen_descriptor);
+
+        rpass.pop_debug_group();
+    }
+
+    /// Executes the egui render pass onto an existing wgpu renderpass.
+    pub fn execute_with_renderpass<'rpass>(
+        &'rpass self,
+        rpass: &mut wgpu::RenderPass<'rpass>,
+        paint_jobs: &[egui::epaint::ClippedPrimitive],
+        screen_descriptor: &ScreenDescriptor,
+    ) {
+        let pixels_per_point = screen_descriptor.pixels_per_point;
+        let size_in_pixels = screen_descriptor.size_in_pixels;
+
+        // Whether or not we need to reset the renderpass state because a paint callback has just
+        // run.
+        let mut needs_reset = true;
+
+        let mut index_buffers = self.index_buffers.iter();
+        let mut vertex_buffers = self.vertex_buffers.iter();
+
+        for egui::ClippedPrimitive {
+            clip_rect,
+            primitive,
+        } in paint_jobs
+        {
+            if needs_reset {
+                rpass.set_viewport(
+                    0.0,
+                    0.0,
+                    size_in_pixels[0] as f32,
+                    size_in_pixels[1] as f32,
+                    0.0,
+                    1.0,
+                );
+                rpass.set_pipeline(&self.render_pipeline);
+                rpass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                needs_reset = false;
+            }
+
+            let PixelRect {
+                x,
+                y,
+                width,
+                height,
+            } = calculate_pixel_rect(clip_rect, pixels_per_point, size_in_pixels);
+
+            // Skip rendering with zero-sized clip areas.
+            if width == 0 || height == 0 {
+                // If this is a mesh, we need to advance the index and vertex buffer iterators
+                if let Primitive::Mesh(_) = primitive {
+                    index_buffers.next().unwrap();
+                    vertex_buffers.next().unwrap();
+                }
+                continue;
+            }
+
+            rpass.set_scissor_rect(x, y, width, height);
+
+            match primitive {
+                Primitive::Mesh(mesh) => {
+                    let index_buffer = index_buffers.next().unwrap();
+                    let vertex_buffer = vertex_buffers.next().unwrap();
+
+                    if let Some((_texture, bind_group)) = self.textures.get(&mesh.texture_id) {
+                        rpass.set_bind_group(1, bind_group, &[]);
+                        rpass.set_index_buffer(
+                            index_buffer.buffer.slice(..),
+                            wgpu::IndexFormat::Uint32,
+                        );
+                        rpass.set_vertex_buffer(0, vertex_buffer.buffer.slice(..));
+                        rpass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
+                    } else {
+                        tracing::warn!("Missing texture: {:?}", mesh.texture_id);
+                    }
+                }
+                Primitive::Callback(callback) => {
+                    let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
+                        c
+                    } else {
+                        // We already warned in the `prepare` callback
+                        continue;
+                    };
+
+                    if callback.rect.is_positive() {
+                        needs_reset = true;
+
+                        // Set the viewport rect
+                        let PixelRect {
+                            x,
+                            y,
+                            width,
+                            height,
+                        } = calculate_pixel_rect(&callback.rect, pixels_per_point, size_in_pixels);
+                        rpass.set_viewport(
+                            x as f32,
+                            y as f32,
+                            width as f32,
+                            height as f32,
+                            0.0,
+                            1.0,
+                        );
+
+                        // Set the scissor rect
+                        let PixelRect {
+                            x,
+                            y,
+                            width,
+                            height,
+                        } = calculate_pixel_rect(clip_rect, pixels_per_point, size_in_pixels);
+                        // Skip rendering with zero-sized clip areas.
+                        if width == 0 || height == 0 {
+                            continue;
+                        }
+                        rpass.set_scissor_rect(x, y, width, height);
+
+                        (cbfn.paint)(
+                            PaintCallbackInfo {
+                                viewport: callback.rect,
+                                clip_rect: *clip_rect,
+                                pixels_per_point,
+                                screen_size_px: size_in_pixels,
+                            },
+                            rpass,
+                            &self.paint_callback_resources,
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    /// Should be called before `execute()`.
+    pub fn update_texture(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        id: egui::TextureId,
+        image_delta: &egui::epaint::ImageDelta,
+    ) {
+        let width = image_delta.image.width() as u32;
+        let height = image_delta.image.height() as u32;
+
+        let size = wgpu::Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        };
+
+        let data_color32 = match &image_delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    width as usize * height as usize,
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                Cow::Borrowed(&image.pixels)
+            }
+            egui::ImageData::Font(image) => {
+                assert_eq!(
+                    width as usize * height as usize,
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                Cow::Owned(image.srgba_pixels(1.0).collect::<Vec<_>>())
+            }
+        };
+        let data_bytes: &[u8] = bytemuck::cast_slice(data_color32.as_slice());
+
+        let queue_write_data_to_texture = |texture, origin| {
+            queue.write_texture(
+                wgpu::ImageCopyTexture {
+                    texture,
+                    mip_level: 0,
+                    origin,
+                    aspect: wgpu::TextureAspect::All,
+                },
+                data_bytes,
+                wgpu::ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: NonZeroU32::new(4 * width),
+                    rows_per_image: NonZeroU32::new(height),
+                },
+                size,
+            );
+        };
+
+        if let Some(pos) = image_delta.pos {
+            // update the existing texture
+            let (texture, _bind_group) = self
+                .textures
+                .get(&id)
+                .expect("Tried to update a texture that has not been allocated yet.");
+            let origin = wgpu::Origin3d {
+                x: pos[0] as u32,
+                y: pos[1] as u32,
+                z: 0,
+            };
+            queue_write_data_to_texture(
+                texture.as_ref().expect("Tried to update user texture."),
+                origin,
+            );
+        } else {
+            // allocate a new texture
+            let texture = device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size,
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8UnormSrgb,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            });
+            let filter = match image_delta.filter {
+                egui::TextureFilter::Nearest => wgpu::FilterMode::Nearest,
+                egui::TextureFilter::Linear => wgpu::FilterMode::Linear,
+            };
+            let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+                label: None,
+                mag_filter: filter,
+                min_filter: filter,
+                ..Default::default()
+            });
+            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: None,
+                layout: &self.texture_bind_group_layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(
+                            &texture.create_view(&wgpu::TextureViewDescriptor::default()),
+                        ),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(&sampler),
+                    },
+                ],
+            });
+            let origin = wgpu::Origin3d::ZERO;
+            queue_write_data_to_texture(&texture, origin);
+            self.textures.insert(id, (Some(texture), bind_group));
+        };
+    }
+
+    pub fn free_texture(&mut self, id: &egui::TextureId) {
+        self.textures.remove(id);
+    }
+
+    /// Get the WGPU texture and bind group associated to a texture that has been allocated by egui.
+    ///
+    /// This could be used by custom paint hooks to render images that have been added through with
+    /// [`egui_extras::RetainedImage`](https://docs.rs/egui_extras/latest/egui_extras/image/struct.RetainedImage.html)
+    /// or [`egui::Context::load_texture`].
+    pub fn get_texture(
+        &self,
+        id: &egui::TextureId,
+    ) -> Option<&(Option<wgpu::Texture>, wgpu::BindGroup)> {
+        self.textures.get(id)
+    }
+
+    /// Registers a `wgpu::Texture` with a `egui::TextureId`.
+    ///
+    /// This enables the application to reference the texture inside an image ui element.
+    /// This effectively enables off-screen rendering inside the egui UI. Texture must have
+    /// the texture format `TextureFormat::Rgba8UnormSrgb` and
+    /// Texture usage `TextureUsage::SAMPLED`.
+    pub fn register_native_texture(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        texture_filter: wgpu::FilterMode,
+    ) -> egui::TextureId {
+        self.register_native_texture_with_sampler_options(
+            device,
+            texture,
+            wgpu::SamplerDescriptor {
+                label: Some(
+                    format!(
+                        "egui_user_image_{}_texture_sampler",
+                        self.next_user_texture_id
+                    )
+                    .as_str(),
+                ),
+                mag_filter: texture_filter,
+                min_filter: texture_filter,
+                ..Default::default()
+            },
+        )
+    }
+
+    /// Registers a `wgpu::Texture` with a `egui::TextureId` while also accepting custom
+    /// `wgpu::SamplerDescriptor` options.
+    ///
+    /// This allows applications to specify individual minification/magnification filters as well as
+    /// custom mipmap and tiling options.
+    ///
+    /// The `Texture` must have the format `TextureFormat::Rgba8UnormSrgb` and usage
+    /// `TextureUsage::SAMPLED`. Any compare function supplied in the `SamplerDescriptor` will be
+    /// ignored.
+    #[allow(clippy::needless_pass_by_value)] // false positive
+    pub fn register_native_texture_with_sampler_options(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        sampler_descriptor: wgpu::SamplerDescriptor<'_>,
+    ) -> egui::TextureId {
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            compare: None,
+            ..sampler_descriptor
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some(
+                format!(
+                    "egui_user_image_{}_texture_bind_group",
+                    self.next_user_texture_id
+                )
+                .as_str(),
+            ),
+            layout: &self.texture_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(texture),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+            ],
+        });
+
+        let id = egui::TextureId::User(self.next_user_texture_id);
+        self.textures.insert(id, (None, bind_group));
+        self.next_user_texture_id += 1;
+
+        id
+    }
+
+    /// Uploads the uniform, vertex and index data used by the render pass.
+    /// Should be called before `execute()`.
+    pub fn update_buffers(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        paint_jobs: &[egui::epaint::ClippedPrimitive],
+        screen_descriptor: &ScreenDescriptor,
+    ) {
+        let screen_size_in_points = screen_descriptor.screen_size_in_points();
+
+        self.update_buffer(
+            device,
+            queue,
+            &BufferType::Uniform,
+            0,
+            bytemuck::cast_slice(&[UniformBuffer {
+                screen_size_in_points,
+                _padding: Default::default(),
+            }]),
+        );
+
+        let mut mesh_idx = 0;
+        for egui::ClippedPrimitive { primitive, .. } in paint_jobs.iter() {
+            match primitive {
+                Primitive::Mesh(mesh) => {
+                    let data: &[u8] = bytemuck::cast_slice(&mesh.indices);
+                    if mesh_idx < self.index_buffers.len() {
+                        self.update_buffer(device, queue, &BufferType::Index, mesh_idx, data);
+                    } else {
+                        let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                            label: Some("egui_index_buffer"),
+                            contents: data,
+                            usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
+                        });
+                        self.index_buffers.push(SizedBuffer {
+                            buffer,
+                            size: data.len(),
+                        });
+                    }
+
+                    let data: &[u8] = bytemuck::cast_slice(&mesh.vertices);
+                    if mesh_idx < self.vertex_buffers.len() {
+                        self.update_buffer(device, queue, &BufferType::Vertex, mesh_idx, data);
+                    } else {
+                        let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                            label: Some("egui_vertex_buffer"),
+                            contents: data,
+                            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+                        });
+
+                        self.vertex_buffers.push(SizedBuffer {
+                            buffer,
+                            size: data.len(),
+                        });
+                    }
+
+                    mesh_idx += 1;
+                }
+                Primitive::Callback(callback) => {
+                    let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
+                        c
+                    } else {
+                        tracing::warn!("Unknown paint callback: expected `egui_gpu::CallbackFn`");
+                        continue;
+                    };
+
+                    (cbfn.prepare)(device, queue, &mut self.paint_callback_resources);
+                }
+            }
+        }
+    }
+
+    /// Updates the buffers used by egui. Will properly re-size the buffers if needed.
+    fn update_buffer(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        buffer_type: &BufferType,
+        index: usize,
+        data: &[u8],
+    ) {
+        let (buffer, storage, label) = match buffer_type {
+            BufferType::Index => (
+                &mut self.index_buffers[index],
+                wgpu::BufferUsages::INDEX,
+                "egui_index_buffer",
+            ),
+            BufferType::Vertex => (
+                &mut self.vertex_buffers[index],
+                wgpu::BufferUsages::VERTEX,
+                "egui_vertex_buffer",
+            ),
+            BufferType::Uniform => (
+                &mut self.uniform_buffer,
+                wgpu::BufferUsages::UNIFORM,
+                "egui_uniform_buffer",
+            ),
+        };
+
+        if data.len() > buffer.size {
+            buffer.size = data.len();
+            buffer.buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some(label),
+                contents: bytemuck::cast_slice(data),
+                usage: storage | wgpu::BufferUsages::COPY_DST,
+            });
+        } else {
+            queue.write_buffer(&buffer.buffer, 0, data);
+        }
+    }
+}
+
+/// A Rect in physical pixel space, used for setting viewport and cliipping rectangles.
+struct PixelRect {
+    x: u32,
+    y: u32,
+    width: u32,
+    height: u32,
+}
+
+/// Convert the Egui clip rect to a physical pixel rect we can use for the GPU viewport/scissor
+fn calculate_pixel_rect(
+    clip_rect: &egui::Rect,
+    pixels_per_point: f32,
+    target_size: [u32; 2],
+) -> PixelRect {
+    // Transform clip rect to physical pixels.
+    let clip_min_x = pixels_per_point * clip_rect.min.x;
+    let clip_min_y = pixels_per_point * clip_rect.min.y;
+    let clip_max_x = pixels_per_point * clip_rect.max.x;
+    let clip_max_y = pixels_per_point * clip_rect.max.y;
+
+    // Make sure clip rect can fit within an `u32`.
+    let clip_min_x = clip_min_x.clamp(0.0, target_size[0] as f32);
+    let clip_min_y = clip_min_y.clamp(0.0, target_size[1] as f32);
+    let clip_max_x = clip_max_x.clamp(clip_min_x, target_size[0] as f32);
+    let clip_max_y = clip_max_y.clamp(clip_min_y, target_size[1] as f32);
+
+    let clip_min_x = clip_min_x.round() as u32;
+    let clip_min_y = clip_min_y.round() as u32;
+    let clip_max_x = clip_max_x.round() as u32;
+    let clip_max_y = clip_max_y.round() as u32;
+
+    let width = (clip_max_x - clip_min_x).max(1);
+    let height = (clip_max_y - clip_min_y).max(1);
+
+    // Clip scissor rectangle to target size.
+    let x = clip_min_x.min(target_size[0]);
+    let y = clip_min_y.min(target_size[1]);
+    let width = width.min(target_size[0] - x);
+    let height = height.min(target_size[1] - y);
+
+    PixelRect {
+        x,
+        y,
+        width,
+        height,
+    }
+}

egui-wgpu/src/winit.rs

@@ -0,0 +1,308 @@
+use std::sync::Arc;
+
+use egui::mutex::RwLock;
+use tracing::error;
+use wgpu::{Adapter, Instance, Surface, TextureFormat};
+
+use crate::renderer;
+
+/// Access to the render state for egui, which can be useful in combination with
+/// [`egui::PaintCallback`]s for custom rendering using WGPU.
+#[derive(Clone)]
+pub struct RenderState {
+    pub device: Arc<wgpu::Device>,
+    pub queue: Arc<wgpu::Queue>,
+    pub target_format: TextureFormat,
+    pub egui_rpass: Arc<RwLock<renderer::RenderPass>>,
+}
+
+struct SurfaceState {
+    surface: Surface,
+    width: u32,
+    height: u32,
+}
+
+/// Everything you need to paint egui with [`wgpu`] on [`winit`].
+///
+/// Alternatively you can use [`crate::renderer`] directly.
+pub struct Painter<'a> {
+    power_preference: wgpu::PowerPreference,
+    device_descriptor: wgpu::DeviceDescriptor<'a>,
+    present_mode: wgpu::PresentMode,
+    msaa_samples: u32,
+
+    instance: Instance,
+    adapter: Option<Adapter>,
+    render_state: Option<RenderState>,
+    surface_state: Option<SurfaceState>,
+}
+
+impl<'a> Painter<'a> {
+    /// Manages [`wgpu`] state, including surface state, required to render egui.
+    ///
+    /// Only the [`wgpu::Instance`] is initialized here. Device selection and the initialization
+    /// of render + surface state is deferred until the painter is given its first window target
+    /// via [`set_window()`](Self::set_window). (Ensuring that a device that's compatible with the
+    /// native window is chosen)
+    ///
+    /// Before calling [`paint_and_update_textures()`](Self::paint_and_update_textures) a
+    /// [`wgpu::Surface`] must be initialized (and corresponding render state) by calling
+    /// [`set_window()`](Self::set_window) once you have
+    /// a [`winit::window::Window`] with a valid `.raw_window_handle()`
+    /// associated.
+    pub fn new(
+        backends: wgpu::Backends,
+        power_preference: wgpu::PowerPreference,
+        device_descriptor: wgpu::DeviceDescriptor<'a>,
+        present_mode: wgpu::PresentMode,
+        msaa_samples: u32,
+    ) -> Self {
+        let instance = wgpu::Instance::new(backends);
+
+        Self {
+            power_preference,
+            device_descriptor,
+            present_mode,
+            msaa_samples,
+
+            instance,
+            adapter: None,
+            render_state: None,
+            surface_state: None,
+        }
+    }
+
+    /// Get the [`RenderState`].
+    ///
+    /// Will return [`None`] if the render state has not been initialized yet.
+    pub fn get_render_state(&self) -> Option<RenderState> {
+        self.render_state.as_ref().cloned()
+    }
+
+    async fn init_render_state(
+        &self,
+        adapter: &Adapter,
+        target_format: TextureFormat,
+    ) -> RenderState {
+        let (device, queue) =
+            pollster::block_on(adapter.request_device(&self.device_descriptor, None)).unwrap();
+
+        let rpass = renderer::RenderPass::new(&device, target_format, self.msaa_samples);
+
+        RenderState {
+            device: Arc::new(device),
+            queue: Arc::new(queue),
+            target_format,
+            egui_rpass: Arc::new(RwLock::new(rpass)),
+        }
+    }
+
+    // We want to defer the initialization of our render state until we have a surface
+    // so we can take its format into account.
+    //
+    // After we've initialized our render state once though we expect all future surfaces
+    // will have the same format and so this render state will remain valid.
+    fn ensure_render_state_for_surface(&mut self, surface: &Surface) {
+        self.adapter.get_or_insert_with(|| {
+            pollster::block_on(self.instance.request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: self.power_preference,
+                compatible_surface: Some(surface),
+                force_fallback_adapter: false,
+            }))
+            .unwrap()
+        });
+
+        if self.render_state.is_none() {
+            let adapter = self.adapter.as_ref().unwrap();
+            let swapchain_format = surface.get_supported_formats(adapter)[0];
+
+            let rs = pollster::block_on(self.init_render_state(adapter, swapchain_format));
+            self.render_state = Some(rs);
+        }
+    }
+
+    fn configure_surface(&mut self, width_in_pixels: u32, height_in_pixels: u32) {
+        let render_state = self
+            .render_state
+            .as_ref()
+            .expect("Render state should exist before surface configuration");
+        let format = render_state.target_format;
+
+        let config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format,
+            width: width_in_pixels,
+            height: height_in_pixels,
+            present_mode: self.present_mode,
+        };
+
+        let surface_state = self
+            .surface_state
+            .as_mut()
+            .expect("Surface state should exist before surface configuration");
+        surface_state
+            .surface
+            .configure(&render_state.device, &config);
+        surface_state.width = width_in_pixels;
+        surface_state.height = height_in_pixels;
+    }
+
+    /// Updates (or clears) the [`winit::window::Window`] associated with the [`Painter`]
+    ///
+    /// This creates a [`wgpu::Surface`] for the given Window (as well as initializing render
+    /// state if needed) that is used for egui rendering.
+    ///
+    /// This must be called before trying to render via
+    /// [`paint_and_update_textures`](Self::paint_and_update_textures)
+    ///
+    /// # Portability
+    ///
+    /// _In particular it's important to note that on Android a it's only possible to create
+    /// a window surface between `Resumed` and `Paused` lifecycle events, and Winit will panic on
+    /// attempts to query the raw window handle while paused._
+    ///
+    /// On Android [`set_window`](Self::set_window) should be called with `Some(window)` for each
+    /// `Resumed` event and `None` for each `Paused` event. Currently, on all other platforms
+    /// [`set_window`](Self::set_window) may be called with `Some(window)` as soon as you have a
+    /// valid [`winit::window::Window`].
+    ///
+    /// # Safety
+    ///
+    /// The raw Window handle associated with the given `window` must be a valid object to create a
+    /// surface upon and must remain valid for the lifetime of the created surface. (The surface may
+    /// be cleared by passing `None`).
+    pub unsafe fn set_window(&mut self, window: Option<&winit::window::Window>) {
+        match window {
+            Some(window) => {
+                let surface = self.instance.create_surface(&window);
+
+                self.ensure_render_state_for_surface(&surface);
+
+                let size = window.inner_size();
+                let width = size.width as u32;
+                let height = size.height as u32;
+                self.surface_state = Some(SurfaceState {
+                    surface,
+                    width,
+                    height,
+                });
+                self.configure_surface(width, height);
+            }
+            None => {
+                self.surface_state = None;
+            }
+        }
+    }
+
+    /// Returns the maximum texture dimension supported if known
+    ///
+    /// This API will only return a known dimension after `set_window()` has been called
+    /// at least once, since the underlying device and render state are initialized lazily
+    /// once we have a window (that may determine the choice of adapter/device).
+    pub fn max_texture_side(&self) -> Option<usize> {
+        self.render_state
+            .as_ref()
+            .map(|rs| rs.device.limits().max_texture_dimension_2d as usize)
+    }
+
+    pub fn on_window_resized(&mut self, width_in_pixels: u32, height_in_pixels: u32) {
+        if self.surface_state.is_some() {
+            self.configure_surface(width_in_pixels, height_in_pixels);
+        } else {
+            error!("Ignoring window resize notification with no surface created via Painter::set_window()");
+        }
+    }
+
+    pub fn paint_and_update_textures(
+        &mut self,
+        pixels_per_point: f32,
+        clear_color: egui::Rgba,
+        clipped_primitives: &[egui::ClippedPrimitive],
+        textures_delta: &egui::TexturesDelta,
+    ) {
+        let render_state = match self.render_state.as_mut() {
+            Some(rs) => rs,
+            None => return,
+        };
+        let surface_state = match self.surface_state.as_ref() {
+            Some(rs) => rs,
+            None => return,
+        };
+
+        let output_frame = match surface_state.surface.get_current_texture() {
+            Ok(frame) => frame,
+            Err(wgpu::SurfaceError::Outdated) => {
+                // This error occurs when the app is minimized on Windows.
+                // Silently return here to prevent spamming the console with:
+                // "The underlying surface has changed, and therefore the swap chain must be updated"
+                return;
+            }
+            Err(e) => {
+                tracing::warn!("Dropped frame with error: {e}");
+                return;
+            }
+        };
+        let output_view = output_frame
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+
+        let mut encoder =
+            render_state
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                    label: Some("encoder"),
+                });
+
+        // Upload all resources for the GPU.
+        let screen_descriptor = renderer::ScreenDescriptor {
+            size_in_pixels: [surface_state.width, surface_state.height],
+            pixels_per_point,
+        };
+
+        {
+            let mut rpass = render_state.egui_rpass.write();
+            for (id, image_delta) in &textures_delta.set {
+                rpass.update_texture(&render_state.device, &render_state.queue, *id, image_delta);
+            }
+
+            rpass.update_buffers(
+                &render_state.device,
+                &render_state.queue,
+                clipped_primitives,
+                &screen_descriptor,
+            );
+        }
+
+        // Record all render passes.
+        render_state.egui_rpass.read().execute(
+            &mut encoder,
+            &output_view,
+            clipped_primitives,
+            &screen_descriptor,
+            Some(wgpu::Color {
+                r: clear_color.r() as f64,
+                g: clear_color.g() as f64,
+                b: clear_color.b() as f64,
+                a: clear_color.a() as f64,
+            }),
+        );
+
+        {
+            let mut rpass = render_state.egui_rpass.write();
+            for id in &textures_delta.free {
+                rpass.free_texture(id);
+            }
+        }
+
+        // Submit the commands.
+        render_state.queue.submit(std::iter::once(encoder.finish()));
+
+        // Redraw egui
+        output_frame.present();
+    }
+
+    #[allow(clippy::unused_self)]
+    pub fn destroy(&mut self) {
+        // TODO(emilk): something here?
+    }
+}

egui-winit/CHANGELOG.md

@@ -3,36 +3,8 @@ All notable changes to the `egui-winit` integration will be noted in this file.
 
 
 ## Unreleased
-
+* Fix clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
-
+* Allow deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634))
-## 0.21.1 - 2023-02-12
-* Fixed crash when window position is in an invalid state, which could happen e.g. due to changes in monitor size or DPI ([#2722](https://github.com/emilk/egui/issues/2722)).
-
-
-## 0.21.0 - 2023-02-08
-* Fixed persistence of native window position on Windows OS ([#2583](https://github.com/emilk/egui/issues/2583)).
-* Update to `winit` 0.28, adding support for mac trackpad zoom ([#2654](https://github.com/emilk/egui/pull/2654)).
-* Remove the `screen_reader` feature. Use the `accesskit` feature flag instead ([#2669](https://github.com/emilk/egui/pull/2669)).
-* Fix bug where the cursor could get stuck using the wrong icon.
-
-
-## 0.20.1 - 2022-12-11
-* Fix [docs.rs](https://docs.rs/egui-winit) build ([#2420](https://github.com/emilk/egui/pull/2420)).
-
-
-## 0.20.0 - 2022-12-08
-* The default features of the `winit` crate are not enabled if the default features of `egui-winit` are disabled too ([#1971](https://github.com/emilk/egui/pull/1971)).
-* Added new feature `wayland` which enables Wayland support ([#1971](https://github.com/emilk/egui/pull/1971)).
-* Don't repaint when just moving window ([#1980](https://github.com/emilk/egui/pull/1980)).
-* Added optional integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
-
-## 0.19.0 - 2022-08-20
-* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
-* Fixed clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
-* Allow deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634)).
-* Fixed window position persistence ([#1745](https://github.com/emilk/egui/pull/1745)).
-* Fixed mouse cursor change on Linux ([#1747](https://github.com/emilk/egui/pull/1747)).
-* Use the new `RawInput::has_focus` field to indicate whether the window has the keyboard focus ([#1859](https://github.com/emilk/egui/pull/1859)).
 
 
 ## 0.18.0 - 2022-04-30

egui-winit/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "egui-winit"
-version = "0.21.1"
+version = "0.18.0"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Bindings for using egui with winit"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.60"
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+homepage = "https://github.com/emilk/egui/tree/master/egui-winit"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+repository = "https://github.com/emilk/egui/tree/master/egui-winit"
 categories = ["gui", "game-development"]
 keywords = ["winit", "egui", "gui", "gamedev"]
 include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
@@ -18,10 +18,7 @@ all-features = true
 
 
 [features]
-default = ["clipboard", "links", "wayland", "winit/default"]
+default = ["clipboard", "links"]
-
-## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
-accesskit = ["accesskit_winit", "egui/accesskit"]
 
 ## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast [`egui::epaint::Vertex`], [`egui::Vec2`] etc to `&[u8]`.
 bytemuck = ["egui/bytemuck"]
@@ -36,41 +33,34 @@ links = ["webbrowser"]
 ## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
 puffin = ["dep:puffin"]
 
+## Experimental support for a screen reader.
+screen_reader = ["tts"]
+
 ## Allow serialization of [`WindowSettings`] using [`serde`](https://docs.rs/serde).
 serde = ["egui/serde", "dep:serde"]
 
-## Enables Wayland support.
-wayland = ["winit/wayland"]
 
 [dependencies]
-egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
+egui = { version = "0.18.0", path = "../egui", default-features = false, features = [
   "tracing",
 ] }
-instant = { version = "0.1", features = [
+instant = { version = "0.1", features = ["wasm-bindgen"] } # We use instant so we can (maybe) compile for web
-  "wasm-bindgen",
+tracing = "0.1"
-] } # We use instant so we can (maybe) compile for web
+winit = "0.26.1"
-tracing = { version = "0.1", default-features = false, features = ["std"] }
-winit = { version = "0.28", default-features = false }
 
 #! ### Optional dependencies
-
+arboard = { version = "2.1", optional = true, default-features = false }
-# feature accesskit
-accesskit_winit = { version = "0.10.0", optional = true }
 
 ## Enable this when generating docs.
 document-features = { version = "0.2", optional = true }
 
-puffin = { version = "0.14", optional = true }
+puffin = { version = "0.13", optional = true }
 serde = { version = "1.0", optional = true, features = ["derive"] }
 
-webbrowser = { version = "0.8.3", optional = true }
+# feature screen_reader
+tts = { version = "0.20", optional = true } # Can't use 0.22 due to compilation problems on linux: https://github.com/emilk/egui/runs/7170127089?check_suite_focus=true#step:5:713
+
+webbrowser = { version = "0.7", optional = true }
 
 [target.'cfg(any(target_os="linux", target_os="dragonfly", target_os="freebsd", target_os="netbsd", target_os="openbsd"))'.dependencies]
 smithay-clipboard = { version = "0.6.3", optional = true }
-
-[target.'cfg(not(target_os = "android"))'.dependencies]
-arboard = { version = "3.2", optional = true, default-features = false }
-
-[target.'cfg(target_os = "android")'.dependencies]
-# TODO(emilk): this is probably not the right place for specifying native-activity, but we need to do it somewhere for the CI
-android-activity = { version = "0.4", features = ["native-activity"] }

egui-winit/README.md

@@ -6,6 +6,6 @@
 ![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
 ![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
 
-This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [`winit`](https://crates.io/crates/winit).
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [winit](https://crates.io/crates/winit).
 
 The library translates winit events to egui, handled copy/paste, updates the cursor, open links clicked in egui, etc.

egui-winit/src/clipboard.rs

@@ -5,7 +5,7 @@ use std::os::raw::c_void;
 /// If the "clipboard" feature is off, or we cannot connect to the OS clipboard,
 /// then a fallback clipboard that just works works within the same app is used instead.
 pub struct Clipboard {
-    #[cfg(all(feature = "arboard", not(target_os = "android")))]
+    #[cfg(feature = "arboard")]
     arboard: Option<arboard::Clipboard>,
 
     #[cfg(all(
@@ -28,9 +28,8 @@ impl Clipboard {
     #[allow(unused_variables)]
     pub fn new(#[allow(unused_variables)] wayland_display: Option<*mut c_void>) -> Self {
         Self {
-            #[cfg(all(feature = "arboard", not(target_os = "android")))]
+            #[cfg(feature = "arboard")]
             arboard: init_arboard(),
-
             #[cfg(all(
                 any(
                     target_os = "linux",
@@ -42,7 +41,6 @@ impl Clipboard {
                 feature = "smithay-clipboard"
             ))]
             smithay: init_smithay_clipboard(wayland_display),
-
             clipboard: Default::default(),
         }
     }
@@ -62,18 +60,18 @@ impl Clipboard {
             return match clipboard.load() {
                 Ok(text) => Some(text),
                 Err(err) => {
-                    tracing::error!("smithay paste error: {err}");
+                    tracing::error!("Paste error: {}", err);
                     None
                 }
             };
         }
 
-        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        #[cfg(feature = "arboard")]
         if let Some(clipboard) = &mut self.arboard {
             return match clipboard.get_text() {
                 Ok(text) => Some(text),
                 Err(err) => {
-                    tracing::error!("arboard paste error: {err}");
+                    tracing::error!("Paste error: {}", err);
                     None
                 }
             };
@@ -98,10 +96,10 @@ impl Clipboard {
             return;
         }
 
-        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        #[cfg(feature = "arboard")]
         if let Some(clipboard) = &mut self.arboard {
             if let Err(err) = clipboard.set_text(text) {
-                tracing::error!("arboard copy/cut error: {err}");
+                tracing::error!("Copy/Cut error: {}", err);
             }
             return;
         }
@@ -110,13 +108,12 @@ impl Clipboard {
     }
 }
 
-#[cfg(all(feature = "arboard", not(target_os = "android")))]
+#[cfg(feature = "arboard")]
 fn init_arboard() -> Option<arboard::Clipboard> {
-    tracing::debug!("Initializing arboard clipboard…");
     match arboard::Clipboard::new() {
         Ok(clipboard) => Some(clipboard),
         Err(err) => {
-            tracing::warn!("Failed to initialize arboard clipboard: {err}");
+            tracing::error!("Failed to initialize clipboard: {}", err);
             None
         }
     }
@@ -136,11 +133,10 @@ fn init_smithay_clipboard(
     wayland_display: Option<*mut c_void>,
 ) -> Option<smithay_clipboard::Clipboard> {
     if let Some(display) = wayland_display {
-        tracing::debug!("Initializing smithay clipboard…");
         #[allow(unsafe_code)]
         Some(unsafe { smithay_clipboard::Clipboard::new(display) })
     } else {
-        tracing::debug!("Cannot initialize smithay clipboard without a display handle");
+        tracing::error!("Cannot initialize smithay clipboard without a display handle!");
         None
     }
 }

egui-winit/src/lib.rs

@@ -11,19 +11,24 @@
 
 use std::os::raw::c_void;
 
-#[cfg(feature = "accesskit")]
-pub use accesskit_winit;
 pub use egui;
-#[cfg(feature = "accesskit")]
-use egui::accesskit;
 pub use winit;
 
 pub mod clipboard;
+pub mod screen_reader;
 mod window_settings;
 
 pub use window_settings::WindowSettings;
 
 use winit::event_loop::EventLoopWindowTarget;
+#[cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+use winit::platform::unix::EventLoopWindowTargetExtUnix;
 
 pub fn native_pixels_per_point(window: &winit::window::Window) -> f32 {
     window.scale_factor() as f32
@@ -34,37 +39,18 @@ pub fn screen_size_in_pixels(window: &winit::window::Window) -> egui::Vec2 {
     egui::vec2(size.width as f32, size.height as f32)
 }
 
-// ----------------------------------------------------------------------------
-
-#[must_use]
-pub struct EventResponse {
-    /// If true, egui consumed this event, i.e. wants exclusive use of this event
-    /// (e.g. a mouse click on an egui window, or entering text into a text field).
-    ///
-    /// For instance, if you use egui for a game, you should only
-    /// pass on the events to your game when [`Self::consumed`] is `false.
-    ///
-    /// Note that egui uses `tab` to move focus between elements, so this will always be `true` for tabs.
-    pub consumed: bool,
-
-    /// Do we need an egui refresh because of this event?
-    pub repaint: bool,
-}
-
-// ----------------------------------------------------------------------------
-
 /// Handles the integration between egui and winit.
 pub struct State {
     start_time: instant::Instant,
     egui_input: egui::RawInput,
     pointer_pos_in_points: Option<egui::Pos2>,
     any_pointer_button_down: bool,
-    current_cursor_icon: Option<egui::CursorIcon>,
+    current_cursor_icon: egui::CursorIcon,
-
     /// What egui uses.
     current_pixels_per_point: f32,
 
     clipboard: clipboard::Clipboard,
+    screen_reader: screen_reader::ScreenReader,
 
     /// If `true`, mouse inputs will be treated as touches.
     /// Useful for debugging touch support in egui.
@@ -76,59 +62,30 @@ pub struct State {
     ///
     /// Only one touch will be interpreted as pointer at any time.
     pointer_touch_id: Option<u64>,
-
-    /// track ime state
-    input_method_editor_started: bool,
-
-    #[cfg(feature = "accesskit")]
-    accesskit: Option<accesskit_winit::Adapter>,
 }
 
 impl State {
     pub fn new<T>(event_loop: &EventLoopWindowTarget<T>) -> Self {
-        Self::new_with_wayland_display(wayland_display(event_loop))
+        Self::new_with_wayland_display(get_wayland_display(event_loop))
     }
 
     pub fn new_with_wayland_display(wayland_display: Option<*mut c_void>) -> Self {
-        let egui_input = egui::RawInput {
-            has_focus: false, // winit will tell us when we have focus
-            ..Default::default()
-        };
-
         Self {
             start_time: instant::Instant::now(),
-            egui_input,
+            egui_input: Default::default(),
             pointer_pos_in_points: None,
             any_pointer_button_down: false,
-            current_cursor_icon: None,
+            current_cursor_icon: egui::CursorIcon::Default,
             current_pixels_per_point: 1.0,
 
             clipboard: clipboard::Clipboard::new(wayland_display),
+            screen_reader: screen_reader::ScreenReader::default(),
 
             simulate_touch_screen: false,
             pointer_touch_id: None,
-
-            input_method_editor_started: false,
-
-            #[cfg(feature = "accesskit")]
-            accesskit: None,
         }
     }
 
-    #[cfg(feature = "accesskit")]
-    pub fn init_accesskit<T: From<accesskit_winit::ActionRequestEvent> + Send>(
-        &mut self,
-        window: &winit::window::Window,
-        event_loop_proxy: winit::event_loop::EventLoopProxy<T>,
-        initial_tree_update_factory: impl 'static + FnOnce() -> accesskit::TreeUpdate + Send,
-    ) {
-        self.accesskit = Some(accesskit_winit::Adapter::new(
-            window,
-            initial_tree_update_factory,
-            event_loop_proxy,
-        ));
-    }
-
     /// Call this once a graphics context has been created to update the maximum texture dimensions
     /// that egui will use.
     pub fn set_max_texture_side(&mut self, max_texture_side: usize) {
@@ -190,63 +147,51 @@ impl State {
     /// Call this when there is a new event.
     ///
     /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
+    ///
+    /// Returns `true` if egui wants exclusive use of this event
+    /// (e.g. a mouse click on an egui window, or entering text into a text field).
+    /// For instance, if you use egui for a game, you want to first call this
+    /// and only when this returns `false` pass on the events to your game.
+    ///
+    /// Note that egui uses `tab` to move focus between elements, so this will always return `true` for tabs.
     pub fn on_event(
         &mut self,
         egui_ctx: &egui::Context,
         event: &winit::event::WindowEvent<'_>,
-    ) -> EventResponse {
+    ) -> bool {
         use winit::event::WindowEvent;
         match event {
             WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
                 let pixels_per_point = *scale_factor as f32;
                 self.egui_input.pixels_per_point = Some(pixels_per_point);
                 self.current_pixels_per_point = pixels_per_point;
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             WindowEvent::MouseInput { state, button, .. } => {
                 self.on_mouse_button_input(*state, *button);
-                EventResponse {
+                egui_ctx.wants_pointer_input()
-                    repaint: true,
-                    consumed: egui_ctx.wants_pointer_input(),
-                }
             }
             WindowEvent::MouseWheel { delta, .. } => {
                 self.on_mouse_wheel(*delta);
-                EventResponse {
+                egui_ctx.wants_pointer_input()
-                    repaint: true,
-                    consumed: egui_ctx.wants_pointer_input(),
-                }
             }
             WindowEvent::CursorMoved { position, .. } => {
                 self.on_cursor_moved(*position);
-                EventResponse {
+                egui_ctx.is_using_pointer()
-                    repaint: true,
-                    consumed: egui_ctx.is_using_pointer(),
-                }
             }
             WindowEvent::CursorLeft { .. } => {
                 self.pointer_pos_in_points = None;
                 self.egui_input.events.push(egui::Event::PointerGone);
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             // WindowEvent::TouchpadPressure {device_id, pressure, stage, ..  } => {} // TODO
             WindowEvent::Touch(touch) => {
                 self.on_touch(touch);
-                let consumed = match touch.phase {
+                match touch.phase {
                     winit::event::TouchPhase::Started
                     | winit::event::TouchPhase::Ended
                     | winit::event::TouchPhase::Cancelled => egui_ctx.wants_pointer_input(),
                     winit::event::TouchPhase::Moved => egui_ctx.is_using_pointer(),
-                };
-                EventResponse {
-                    repaint: true,
-                    consumed,
                 }
             }
             WindowEvent::ReceivedCharacter(ch) => {
@@ -255,92 +200,36 @@ impl State {
                 let is_mac_cmd = cfg!(target_os = "macos")
                     && (self.egui_input.modifiers.ctrl || self.egui_input.modifiers.mac_cmd);
 
-                let consumed = if is_printable_char(*ch) && !is_mac_cmd {
+                if is_printable_char(*ch) && !is_mac_cmd && !self.egui_input.modifiers.alt {
                     self.egui_input
                         .events
                         .push(egui::Event::Text(ch.to_string()));
                     egui_ctx.wants_keyboard_input()
                 } else {
                     false
-                };
-                EventResponse {
-                    repaint: true,
-                    consumed,
-                }
-            }
-            WindowEvent::Ime(ime) => {
-                // on Mac even Cmd-C is preessed during ime, a `c` is pushed to Preedit.
-                // So no need to check is_mac_cmd.
-                //
-                // How winit produce `Ime::Enabled` and `Ime::Disabled` differs in MacOS
-                // and Windows.
-                //
-                // - On Windows, before and after each Commit will produce an Enable/Disabled
-                // event.
-                // - On MacOS, only when user explicit enable/disable ime. No Disabled
-                // after Commit.
-                //
-                // We use input_method_editor_started to mannualy insert CompositionStart
-                // between Commits.
-                match ime {
-                    winit::event::Ime::Enabled | winit::event::Ime::Disabled => (),
-                    winit::event::Ime::Commit(text) => {
-                        self.input_method_editor_started = false;
-                        self.egui_input
-                            .events
-                            .push(egui::Event::CompositionEnd(text.clone()));
-                    }
-                    winit::event::Ime::Preedit(text, ..) => {
-                        if !self.input_method_editor_started {
-                            self.input_method_editor_started = true;
-                            self.egui_input.events.push(egui::Event::CompositionStart);
-                        }
-                        self.egui_input
-                            .events
-                            .push(egui::Event::CompositionUpdate(text.clone()));
-                    }
-                };
-
-                EventResponse {
-                    repaint: true,
-                    consumed: egui_ctx.wants_keyboard_input(),
                 }
             }
             WindowEvent::KeyboardInput { input, .. } => {
                 self.on_keyboard_input(input);
-                let consumed = egui_ctx.wants_keyboard_input()
+                egui_ctx.wants_keyboard_input()
-                    || input.virtual_keycode == Some(winit::event::VirtualKeyCode::Tab);
+                    || input.virtual_keycode == Some(winit::event::VirtualKeyCode::Tab)
-                EventResponse {
-                    repaint: true,
-                    consumed,
             }
-            }
+            WindowEvent::Focused(_) => {
-            WindowEvent::Focused(has_focus) => {
-                self.egui_input.has_focus = *has_focus;
                 // We will not be given a KeyboardInput event when the modifiers are released while
                 // the window does not have focus. Unset all modifier state to be safe.
                 self.egui_input.modifiers = egui::Modifiers::default();
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             WindowEvent::HoveredFile(path) => {
                 self.egui_input.hovered_files.push(egui::HoveredFile {
                     path: Some(path.clone()),
                     ..Default::default()
                 });
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             WindowEvent::HoveredFileCancelled => {
                 self.egui_input.hovered_files.clear();
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             WindowEvent::DroppedFile(path) => {
                 self.egui_input.hovered_files.clear();
@@ -348,10 +237,7 @@ impl State {
                     path: Some(path.clone()),
                     ..Default::default()
                 });
-                EventResponse {
+                false
-                    repaint: true,
-                    consumed: false,
-                }
             }
             WindowEvent::ModifiersChanged(state) => {
                 self.egui_input.modifiers.alt = state.alt();
@@ -363,54 +249,13 @@ impl State {
                 } else {
                     state.ctrl()
                 };
-                EventResponse {
+                false
-                    repaint: true,
+            }
-                    consumed: false,
+            _ => {
+                // dbg!(event);
+                false
             }
         }
-
-            // Things that may require repaint:
-            WindowEvent::CloseRequested
-            | WindowEvent::CursorEntered { .. }
-            | WindowEvent::Destroyed
-            | WindowEvent::Occluded(_)
-            | WindowEvent::Resized(_)
-            | WindowEvent::ThemeChanged(_)
-            | WindowEvent::TouchpadPressure { .. } => EventResponse {
-                repaint: true,
-                consumed: false,
-            },
-
-            // Things we completely ignore:
-            WindowEvent::AxisMotion { .. }
-            | WindowEvent::Moved(_)
-            | WindowEvent::SmartMagnify { .. }
-            | WindowEvent::TouchpadRotate { .. } => EventResponse {
-                repaint: false,
-                consumed: false,
-            },
-
-            WindowEvent::TouchpadMagnify { delta, .. } => {
-                // Positive delta values indicate magnification (zooming in).
-                // Negative delta values indicate shrinking (zooming out).
-                let zoom_factor = (*delta as f32).exp();
-                self.egui_input.events.push(egui::Event::Zoom(zoom_factor));
-                EventResponse {
-                    repaint: true,
-                    consumed: egui_ctx.wants_pointer_input(),
-                }
-            }
-        }
-    }
-
-    /// Call this when there is a new [`accesskit::ActionRequest`].
-    ///
-    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
-    #[cfg(feature = "accesskit")]
-    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
-        self.egui_input
-            .events
-            .push(egui::Event::AccessKitActionRequest(request));
     }
 
     fn on_mouse_button_input(
@@ -549,7 +394,7 @@ impl State {
     }
 
     fn on_mouse_wheel(&mut self, delta: winit::event::MouseScrollDelta) {
-        let delta = match delta {
+        let mut delta = match delta {
             winit::event::MouseScrollDelta::LineDelta(x, y) => {
                 let points_per_scroll_line = 50.0; // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
                 egui::vec2(x, y) * points_per_scroll_line
@@ -559,6 +404,8 @@ impl State {
             }
         };
 
+        delta.x *= -1.0; // Winit has inverted hscroll. Remove this line when we update winit after https://github.com/rust-windowing/winit/pull/2105 is merged and released
+
         if self.egui_input.modifiers.ctrl || self.egui_input.modifiers.command {
             // Treat as zoom instead:
             let factor = (delta.y / 200.0).exp();
@@ -599,7 +446,6 @@ impl State {
                 self.egui_input.events.push(egui::Event::Key {
                     key,
                     pressed,
-                    repeat: false, // egui will fill this in for us!
                     modifiers: self.egui_input.modifiers,
                 });
             }
@@ -620,6 +466,11 @@ impl State {
         egui_ctx: &egui::Context,
         platform_output: egui::PlatformOutput,
     ) {
+        if egui_ctx.options().screen_reader {
+            self.screen_reader
+                .speak(&platform_output.events_description());
+        }
+
         let egui::PlatformOutput {
             cursor_icon,
             open_url,
@@ -627,8 +478,6 @@ impl State {
             events: _,                    // handled above
             mutable_text_under_cursor: _, // only used in eframe web
             text_cursor_pos,
-            #[cfg(feature = "accesskit")]
-            accesskit_update,
         } = platform_output;
         self.current_pixels_per_point = egui_ctx.pixels_per_point(); // someone can have changed it to scale the UI
 
@@ -645,35 +494,25 @@ impl State {
         if let Some(egui::Pos2 { x, y }) = text_cursor_pos {
             window.set_ime_position(winit::dpi::LogicalPosition { x, y });
         }
-
-        #[cfg(feature = "accesskit")]
-        if let Some(accesskit) = self.accesskit.as_ref() {
-            if let Some(update) = accesskit_update {
-                accesskit.update_if_active(|| update);
-            }
-        }
     }
 
     fn set_cursor_icon(&mut self, window: &winit::window::Window, cursor_icon: egui::CursorIcon) {
-        if self.current_cursor_icon == Some(cursor_icon) {
+        // prevent flickering near frame boundary when Windows OS tries to control cursor icon for window resizing
-            // Prevent flickering near frame boundary when Windows OS tries to control cursor icon for window resizing.
+        #[cfg(windows)]
-            // On other platforms: just early-out to save CPU.
+        if self.current_cursor_icon == cursor_icon {
             return;
         }
+        self.current_cursor_icon = cursor_icon;
+
+        if let Some(cursor_icon) = translate_cursor(cursor_icon) {
+            window.set_cursor_visible(true);
 
             let is_pointer_in_window = self.pointer_pos_in_points.is_some();
             if is_pointer_in_window {
-            self.current_cursor_icon = Some(cursor_icon);
+                window.set_cursor_icon(cursor_icon);
-
-            if let Some(winit_cursor_icon) = translate_cursor(cursor_icon) {
-                window.set_cursor_visible(true);
-                window.set_cursor_icon(winit_cursor_icon);
-            } else {
-                window.set_cursor_visible(false);
             }
         } else {
-            // Remember to set the cursor again once the cursor returns to the screen:
+            window.set_cursor_visible(false);
-            self.current_cursor_icon = None;
         }
     }
 }
@@ -757,11 +596,6 @@ fn translate_virtual_key_code(key: winit::event::VirtualKeyCode) -> Option<egui:
         VirtualKeyCode::PageUp => Key::PageUp,
         VirtualKeyCode::PageDown => Key::PageDown,
 
-        VirtualKeyCode::Minus => Key::Minus,
-        // Using Mac the key with the Plus sign on it is reported as the Equals key
-        // (with both English and Swedish keyboard).
-        VirtualKeyCode::Equals => Key::PlusEquals,
-
         VirtualKeyCode::Key0 | VirtualKeyCode::Numpad0 => Key::Num0,
         VirtualKeyCode::Key1 | VirtualKeyCode::Numpad1 => Key::Num1,
         VirtualKeyCode::Key2 | VirtualKeyCode::Numpad2 => Key::Num2,
@@ -872,8 +706,7 @@ fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::window::Curs
 }
 
 /// Returns a Wayland display handle if the target is running Wayland
-fn wayland_display<T>(_event_loop: &EventLoopWindowTarget<T>) -> Option<*mut c_void> {
+fn get_wayland_display<T>(_event_loop: &EventLoopWindowTarget<T>) -> Option<*mut c_void> {
-    #[cfg(feature = "wayland")]
     #[cfg(any(
         target_os = "linux",
         target_os = "dragonfly",
@@ -882,7 +715,6 @@ fn wayland_display<T>(_event_loop: &EventLoopWindowTarget<T>) -> Option<*mut c_v
         target_os = "openbsd"
     ))]
     {
-        use winit::platform::wayland::EventLoopWindowTargetExtWayland as _;
         return _event_loop.wayland_display();
     }
 
@@ -903,7 +735,6 @@ macro_rules! profile_function {
         puffin::profile_function!($($arg)*);
     };
 }
-
 #[allow(unused_imports)]
 pub(crate) use profile_function;
 
@@ -915,6 +746,5 @@ macro_rules! profile_scope {
         puffin::profile_scope!($($arg)*);
     };
 }
-
 #[allow(unused_imports)]
 pub(crate) use profile_scope;

egui-winit/src/screen_reader.rs

@@ -0,0 +1,49 @@
+pub struct ScreenReader {
+    #[cfg(feature = "screen_reader")]
+    tts: Option<tts::Tts>,
+}
+
+#[cfg(not(feature = "screen_reader"))]
+#[allow(clippy::derivable_impls)] // False positive
+impl Default for ScreenReader {
+    fn default() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(feature = "screen_reader")]
+impl Default for ScreenReader {
+    fn default() -> Self {
+        let tts = match tts::Tts::default() {
+            Ok(screen_reader) => {
+                tracing::debug!("Initialized screen reader.");
+                Some(screen_reader)
+            }
+            Err(err) => {
+                tracing::warn!("Failed to load screen reader: {}", err);
+                None
+            }
+        };
+        Self { tts }
+    }
+}
+
+impl ScreenReader {
+    #[cfg(not(feature = "screen_reader"))]
+    #[allow(clippy::unused_self)]
+    pub fn speak(&mut self, _text: &str) {}
+
+    #[cfg(feature = "screen_reader")]
+    pub fn speak(&mut self, text: &str) {
+        if text.is_empty() {
+            return;
+        }
+        if let Some(tts) = &mut self.tts {
+            tracing::debug!("Speaking: {:?}", text);
+            let interrupt = true;
+            if let Err(err) = tts.speak(text, interrupt) {
+                tracing::warn!("Failed to read: {}", err);
+            }
+        }
+    }
+}

egui-winit/src/window_settings.rs

@@ -0,0 +1,66 @@
+/// Can be used to store native window settings (position and size).
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WindowSettings {
+    /// Position of window in physical pixels. This is either
+    /// the inner or outer position depending on the platform.
+    /// See [`winit::window::WindowAttributes`] for details.
+    position: Option<egui::Pos2>,
+    /// Inner size of window in logical pixels
+    inner_size_points: Option<egui::Vec2>,
+}
+
+impl WindowSettings {
+    pub fn from_display(window: &winit::window::Window) -> Self {
+        let inner_size_points = window.inner_size().to_logical::<f32>(window.scale_factor());
+        let position = if cfg!(macos) {
+            // MacOS uses inner position when positioning windows.
+            window
+                .inner_position()
+                .ok()
+                .map(|p| egui::pos2(p.x as f32, p.y as f32))
+        } else {
+            // Other platforms use the outer position.
+            window
+                .outer_position()
+                .ok()
+                .map(|p| egui::pos2(p.x as f32, p.y as f32))
+        };
+
+        Self {
+            position,
+            inner_size_points: Some(egui::vec2(
+                inner_size_points.width as f32,
+                inner_size_points.height as f32,
+            )),
+        }
+    }
+
+    pub fn initialize_window(
+        &self,
+        mut window: winit::window::WindowBuilder,
+    ) -> winit::window::WindowBuilder {
+        if !cfg!(target_os = "windows") {
+            // If the app last ran on two monitors and only one is now connected, then
+            // the given position is invalid.
+            // If this happens on Mac, the window is clamped into valid area.
+            // If this happens on Windows, the window is hidden and very difficult to find.
+            // So we don't restore window positions on Windows.
+            if let Some(pos) = self.position {
+                window = window.with_position(winit::dpi::PhysicalPosition {
+                    x: pos.x as f64,
+                    y: pos.y as f64,
+                });
+            }
+        }
+
+        if let Some(inner_size_points) = self.inner_size_points {
+            window.with_inner_size(winit::dpi::LogicalSize {
+                width: inner_size_points.x as f64,
+                height: inner_size_points.y as f64,
+            })
+        } else {
+            window
+        }
+    }
+}

egui/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "egui"
-version = "0.21.0"
+version = "0.18.1"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "An easy-to-use immediate mode GUI that runs on both web and native"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.60"
 homepage = "https://github.com/emilk/egui"
 license = "MIT OR Apache-2.0"
-readme = "../../README.md"
+readme = "../README.md"
 repository = "https://github.com/emilk/egui"
 categories = ["gui", "game-development"]
 keywords = ["gui", "imgui", "immediate", "portable", "gamedev"]
@@ -52,33 +52,20 @@ mint = ["epaint/mint"]
 persistence = ["serde", "epaint/serde", "ron"]
 
 ## Allow serialization using [`serde`](https://docs.rs/serde).
-serde = ["dep:serde", "epaint/serde", "accesskit?/serde"]
+serde = ["dep:serde", "epaint/serde"]
-
-## Change Vertex layout to be compatible with unity
-unity = ["epaint/unity"]
-
 
 [dependencies]
-epaint = { version = "0.21.0", path = "../epaint", default-features = false }
+epaint = { version = "0.18.1", path = "../epaint", default-features = false }
 
-ahash = { version = "0.8.1", default-features = false, features = [
+ahash = "0.7"
-    "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
-    "std",
-] }
 nohash-hasher = "0.2"
 
 #! ### Optional dependencies
-## Exposes detailed accessibility implementation required by platform
-## accessibility APIs. Also requires support in the egui integration.
-accesskit = { version = "0.9.0", optional = true }
-
 ## Enable this when generating docs.
 document-features = { version = "0.2", optional = true }
 
-ron = { version = "0.8", optional = true }
+ron = { version = "0.7", optional = true }
 serde = { version = "1", optional = true, features = ["derive", "rc"] }
 
 # egui doesn't log much, but when it does, it uses [`tracing`](https://docs.rs/tracing).
-tracing = { version = "0.1", optional = true, default-features = false, features = [
+tracing = { version = "0.1", optional = true }
-    "std",
-] }

egui/examples/README.md

@@ -2,6 +2,6 @@ There are no stand-alone egui examples, because egui is not stand-alone!
 
 See the top-level [examples](https://github.com/emilk/egui/tree/master/examples/) folder instead.
 
-There are also plenty of examples in [the online demo](https://www.egui.rs/#demo). You can find the source code for it at <https://github.com/emilk/egui/tree/master/crates/egui_demo_lib>.
+There are also plenty of examples in [the online demo](https://www.egui.rs/#demo). You can find the source code for it at <https://github.com/emilk/egui/tree/master/egui_demo_lib>.
 
 To learn how to set up `eframe` for web and native, go to <https://github.com/emilk/eframe_template/> and follow the instructions there!

egui/src/animation_manager.rs

@@ -9,7 +9,6 @@ pub(crate) struct AnimationManager {
 #[derive(Clone, Debug)]
 struct BoolAnim {
     value: bool,
-
     /// when did `value` last toggle?
     toggle_time: f64,
 }
@@ -17,9 +16,7 @@ struct BoolAnim {
 #[derive(Clone, Debug)]
 struct ValueAnim {
     from_value: f32,
-
     to_value: f32,
-
     /// when did `value` last toggle?
     toggle_time: f64,
 }

egui/src/containers/area.rs

@@ -2,17 +2,17 @@
 //! It has no frame or own size. It is potentially movable.
 //! It is the foundation for windows and popups.
 
+use std::{fmt::Debug, hash::Hash};
+
 use crate::*;
 
 /// State that is persisted between frames.
-// TODO(emilk): this is not currently stored in `Memory::data`, but maybe it should be?
+// TODO(emilk): this is not currently stored in `memory().data`, but maybe it should be?
 #[derive(Clone, Copy, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub(crate) struct State {
-    /// Last known pos of the pivot
+    /// Last known pos
-    pub pivot_pos: Pos2,
+    pub pos: Pos2,
-
-    pub pivot: Align2,
 
     /// Last know size. Used for catching clicks.
     pub size: Vec2,
@@ -23,22 +23,8 @@ pub(crate) struct State {
 }
 
 impl State {
-    pub fn left_top_pos(&self) -> Pos2 {
-        pos2(
-            self.pivot_pos.x - self.pivot.x().to_factor() * self.size.x,
-            self.pivot_pos.y - self.pivot.y().to_factor() * self.size.y,
-        )
-    }
-
-    pub fn set_left_top_pos(&mut self, pos: Pos2) {
-        self.pivot_pos = pos2(
-            pos.x + self.pivot.x().to_factor() * self.size.x,
-            pos.y + self.pivot.y().to_factor() * self.size.y,
-        );
-    }
-
     pub fn rect(&self) -> Rect {
-        Rect::from_min_size(self.left_top_pos(), self.size)
+        Rect::from_min_size(self.pos, self.size)
     }
 }
 
@@ -62,27 +48,23 @@ pub struct Area {
     movable: bool,
     interactable: bool,
     enabled: bool,
-    constrain: bool,
     order: Order,
     default_pos: Option<Pos2>,
-    pivot: Align2,
     anchor: Option<(Align2, Vec2)>,
     new_pos: Option<Pos2>,
     drag_bounds: Option<Rect>,
 }
 
 impl Area {
-    pub fn new(id: impl Into<Id>) -> Self {
+    pub fn new(id_source: impl Hash) -> Self {
         Self {
-            id: id.into(),
+            id: Id::new(id_source),
             movable: true,
             interactable: true,
-            constrain: false,
             enabled: true,
             order: Order::Middle,
             default_pos: None,
             new_pos: None,
-            pivot: Align2::LEFT_TOP,
             anchor: None,
             drag_bounds: None,
         }
@@ -147,24 +129,6 @@ impl Area {
         self
     }
 
-    /// Constrains this area to the screen bounds.
-    pub fn constrain(mut self, constrain: bool) -> Self {
-        self.constrain = constrain;
-        self
-    }
-
-    /// Where the "root" of the area is.
-    ///
-    /// For instance, if you set this to [`Align2::RIGHT_TOP`]
-    /// then [`Self::fixed_pos`] will set the position of the right-top
-    /// corner of the area.
-    ///
-    /// Default: [`Align2::LEFT_TOP`].
-    pub fn pivot(mut self, pivot: Align2) -> Self {
-        self.pivot = pivot;
-        self
-    }
-
     /// Positions the window but you can still move it.
     pub fn current_pos(mut self, current_pos: impl Into<Pos2>) -> Self {
         self.new_pos = Some(current_pos.into());
@@ -205,16 +169,9 @@ impl Area {
 pub(crate) struct Prepared {
     layer_id: LayerId,
     state: State,
-    move_response: Response,
+    pub(crate) movable: bool,
     enabled: bool,
     drag_bounds: Option<Rect>,
-
-    /// We always make windows invisible the first frame to hide "first-frame-jitters".
-    ///
-    /// This is so that we use the first frame to calculate the window size,
-    /// and then can correctly position the window and its contents the next frame,
-    /// without having one frame where the window is wrongly positioned or sized.
-    temporarily_invisible: bool,
 }
 
 impl Area {
@@ -239,95 +196,43 @@ impl Area {
             enabled,
             default_pos,
             new_pos,
-            pivot,
             anchor,
             drag_bounds,
-            constrain,
         } = self;
 
         let layer_id = LayerId::new(order, id);
 
-        let state = ctx.memory(|mem| mem.areas.get(id).copied());
+        let state = ctx.memory().areas.get(id).cloned();
         let is_new = state.is_none();
         if is_new {
             ctx.request_repaint(); // if we don't know the previous size we are likely drawing the area in the wrong place
         }
         let mut state = state.unwrap_or_else(|| State {
-            pivot_pos: default_pos.unwrap_or_else(|| automatic_area_position(ctx)),
+            pos: default_pos.unwrap_or_else(|| automatic_area_position(ctx)),
-            pivot,
             size: Vec2::ZERO,
             interactable,
         });
-        state.pivot_pos = new_pos.unwrap_or(state.pivot_pos);
+        state.pos = new_pos.unwrap_or(state.pos);
         state.interactable = interactable;
 
         if let Some((anchor, offset)) = anchor {
-            let screen = ctx.available_rect();
+            if is_new {
-            state.set_left_top_pos(
+                // unknown size
-                anchor.align_size_within_rect(state.size, screen).left_top() + offset,
-            );
-        }
-
-        // interact right away to prevent frame-delay
-        let move_response = {
-            let interact_id = layer_id.id.with("move");
-            let sense = if movable {
-                Sense::click_and_drag()
-            } else if interactable {
-                Sense::click() // allow clicks to bring to front
-            } else {
-                Sense::hover()
-            };
-
-            let move_response = ctx.interact(
-                Rect::EVERYTHING,
-                ctx.style().spacing.item_spacing,
-                layer_id,
-                interact_id,
-                state.rect(),
-                sense,
-                enabled,
-            );
-
-            // Important check - don't try to move e.g. a combobox popup!
-            if movable {
-                if move_response.dragged() {
-                    state.pivot_pos += ctx.input(|i| i.pointer.delta());
-                }
-
-                state.set_left_top_pos(
-                    ctx.constrain_window_rect_to_area(state.rect(), drag_bounds)
-                        .min,
-                );
-            }
-
-            if (move_response.dragged() || move_response.clicked())
-                || pointer_pressed_on_area(ctx, layer_id)
-                || !ctx.memory(|m| m.areas.visible_last_frame(&layer_id))
-            {
-                ctx.memory_mut(|m| m.areas.move_to_top(layer_id));
                 ctx.request_repaint();
+            } else {
+                let screen = ctx.available_rect();
+                state.pos = anchor.align_size_within_rect(state.size, screen).min + offset;
+            }
         }
 
-            move_response
+        state.pos = ctx.round_pos_to_pixels(state.pos);
-        };
-
-        state.set_left_top_pos(ctx.round_pos_to_pixels(state.left_top_pos()));
-
-        if constrain {
-            state.set_left_top_pos(
-                ctx.constrain_window_rect_to_area(state.rect(), drag_bounds)
-                    .left_top(),
-            );
-        }
 
         Prepared {
             layer_id,
             state,
-            move_response,
+            movable,
             enabled,
             drag_bounds,
-            temporarily_invisible: is_new,
         }
     }
 
@@ -345,7 +250,7 @@ impl Area {
         }
 
         let layer_id = LayerId::new(self.order, self.id);
-        let area_rect = ctx.memory(|mem| mem.areas.get(self.id).map(|area| area.rect()));
+        let area_rect = ctx.memory().areas.get(self.id).map(|area| area.rect());
         if let Some(area_rect) = area_rect {
             let clip_rect = ctx.available_rect();
             let painter = Painter::new(ctx.clone(), layer_id, clip_rect);
@@ -374,7 +279,7 @@ impl Prepared {
     }
 
     pub(crate) fn content_ui(&self, ctx: &Context) -> Ui {
-        let screen_rect = ctx.screen_rect();
+        let screen_rect = ctx.input().screen_rect();
 
         let bounds = if let Some(bounds) = self.drag_bounds {
             bounds.intersect(screen_rect) // protect against infinite bounds
@@ -390,16 +295,14 @@ impl Prepared {
         };
 
         let max_rect = Rect::from_min_max(
-            self.state.left_top_pos(),
+            self.state.pos,
-            bounds
+            bounds.max.at_least(self.state.pos + Vec2::splat(32.0)),
-                .max
-                .at_least(self.state.left_top_pos() + Vec2::splat(32.0)),
         );
 
         let shadow_radius = ctx.style().visuals.window_shadow.extrusion; // hacky
         let clip_rect_margin = ctx.style().visuals.clip_rect_margin.max(shadow_radius);
 
-        let clip_rect = Rect::from_min_max(self.state.left_top_pos(), bounds.max)
+        let clip_rect = Rect::from_min_max(self.state.pos, bounds.max)
             .expand(clip_rect_margin)
             .intersect(bounds);
 
@@ -411,7 +314,7 @@ impl Prepared {
             clip_rect,
         );
         ui.set_enabled(self.enabled);
-        ui.set_visible(!self.temporarily_invisible);
+
         ui
     }
 
@@ -420,15 +323,49 @@ impl Prepared {
         let Prepared {
             layer_id,
             mut state,
-            move_response,
+            movable,
-            enabled: _,
+            enabled,
-            drag_bounds: _,
+            drag_bounds,
-            temporarily_invisible: _,
         } = self;
 
         state.size = content_ui.min_rect().size();
 
-        ctx.memory_mut(|m| m.areas.set_state(layer_id, state));
+        let interact_id = layer_id.id.with("move");
+        let sense = if movable {
+            Sense::click_and_drag()
+        } else {
+            Sense::click() // allow clicks to bring to front
+        };
+
+        let move_response = ctx.interact(
+            Rect::EVERYTHING,
+            ctx.style().spacing.item_spacing,
+            layer_id,
+            interact_id,
+            state.rect(),
+            sense,
+            enabled,
+        );
+
+        if move_response.dragged() && movable {
+            state.pos += ctx.input().pointer.delta();
+        }
+
+        // Important check - don't try to move e.g. a combobox popup!
+        if movable {
+            state.pos = ctx
+                .constrain_window_rect_to_area(state.rect(), drag_bounds)
+                .min;
+        }
+
+        if (move_response.dragged() || move_response.clicked())
+            || pointer_pressed_on_area(ctx, layer_id)
+            || !ctx.memory().areas.visible_last_frame(&layer_id)
+        {
+            ctx.memory().areas.move_to_top(layer_id);
+            ctx.request_repaint();
+        }
+        ctx.memory().areas.set_state(layer_id, state);
 
         move_response
     }
@@ -436,7 +373,7 @@ impl Prepared {
 
 fn pointer_pressed_on_area(ctx: &Context, layer_id: LayerId) -> bool {
     if let Some(pointer_pos) = ctx.pointer_interact_pos() {
-        let any_pressed = ctx.input(|i| i.pointer.any_pressed());
+        let any_pressed = ctx.input().pointer.any_pressed();
         any_pressed && ctx.layer_id_at(pointer_pos) == Some(layer_id)
     } else {
         false
@@ -444,13 +381,13 @@ fn pointer_pressed_on_area(ctx: &Context, layer_id: LayerId) -> bool {
 }
 
 fn automatic_area_position(ctx: &Context) -> Pos2 {
-    let mut existing: Vec<Rect> = ctx.memory(|mem| {
+    let mut existing: Vec<Rect> = ctx
-        mem.areas
+        .memory()
+        .areas
         .visible_windows()
         .into_iter()
         .map(State::rect)
-            .collect()
+        .collect();
-    });
     existing.sort_by_key(|r| r.left().round() as i32);
 
     let available_rect = ctx.available_rect();

egui/src/containers/collapsing_header.rs

@@ -26,14 +26,13 @@ pub struct CollapsingState {
 
 impl CollapsingState {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.data_mut(|d| {
+        ctx.data()
-            d.get_persisted::<InnerState>(id)
+            .get_persisted::<InnerState>(id)
             .map(|state| Self { id, state })
-        })
     }
 
     pub fn store(&self, ctx: &Context) {
-        ctx.data_mut(|d| d.insert_persisted(self.id, self.state));
+        ctx.data().insert_persisted(self.id, self.state);
     }
 
     pub fn id(&self) -> Id {
@@ -65,7 +64,7 @@ impl CollapsingState {
 
     /// 0 for closed, 1 for open, with tweening
     pub fn openness(&self, ctx: &Context) -> f32 {
-        if ctx.memory(|mem| mem.everything_is_visible()) {
+        if ctx.memory().everything_is_visible() {
             1.0
         } else {
             ctx.animate_bool(self.id, self.state.open)
@@ -99,7 +98,7 @@ impl CollapsingState {
         ui: &mut Ui,
         icon_fn: impl FnOnce(&mut Ui, f32, &Response) + 'static,
     ) -> Response {
-        let size = vec2(ui.spacing().indent, ui.spacing().icon_width);
+        let size = Vec2::new(ui.spacing().indent, ui.spacing().icon_width);
         let (_id, rect) = ui.allocate_space(size);
         let response = ui.interact(rect, self.id, Sense::click());
         if response.clicked() {
@@ -112,7 +111,10 @@ impl CollapsingState {
             response.rect.center().y,
         ));
         let openness = self.openness(ui.ctx());
-        let small_icon_response = response.clone().with_new_rect(icon_rect);
+        let small_icon_response = Response {
+            rect: icon_rect,
+            ..response.clone()
+        };
         icon_fn(ui, openness, &small_icon_response);
         response
     }
@@ -141,10 +143,9 @@ impl CollapsingState {
         add_header: impl FnOnce(&mut Ui) -> HeaderRet,
     ) -> HeaderResponse<'_, HeaderRet> {
         let header_response = ui.horizontal(|ui| {
-            let prev_item_spacing = ui.spacing_mut().item_spacing;
             ui.spacing_mut().item_spacing.x = 0.0; // the toggler button uses the full indent width
             let collapser = self.show_default_button_indented(ui);
-            ui.spacing_mut().item_spacing = prev_item_spacing;
+            ui.spacing_mut().item_spacing.x = ui.spacing_mut().icon_spacing; // Restore spacing
             (collapser, add_header(ui))
         });
         HeaderResponse {
@@ -310,6 +311,7 @@ impl<'ui, HeaderRet> HeaderResponse<'ui, HeaderRet> {
 /// Paint the arrow icon that indicated if the region is open or not
 pub fn paint_default_icon(ui: &mut Ui, openness: f32, response: &Response) {
     let visuals = ui.style().interact(response);
+    let stroke = visuals.fg_stroke;
 
     let rect = response.rect;
 
@@ -323,11 +325,7 @@ pub fn paint_default_icon(ui: &mut Ui, openness: f32, response: &Response) {
         *p = rect.center() + rotation * (*p - rect.center());
     }
 
-    ui.painter().add(Shape::convex_polygon(
+    ui.painter().add(Shape::closed_line(points, stroke));
-        points,
-        visuals.fg_stroke.color,
-        Stroke::NONE,
-    ));
 }
 
 /// A function that paints an icon indicating if the region is open or not
@@ -554,7 +552,7 @@ impl CollapsingHeader {
                 ui.painter().add(epaint::RectShape {
                     rect: header_response.rect.expand(visuals.expansion),
                     rounding: visuals.rounding,
-                    fill: visuals.weak_bg_fill,
+                    fill: visuals.bg_fill,
                     stroke: visuals.bg_stroke,
                     // stroke: Default::default(),
                 });
@@ -574,7 +572,10 @@ impl CollapsingHeader {
                     header_response.rect.left() + ui.spacing().indent / 2.0,
                     header_response.rect.center().y,
                 ));
-                let icon_response = header_response.clone().with_new_rect(icon_rect);
+                let icon_response = Response {
+                    rect: icon_rect,
+                    ..header_response.clone()
+                };
                 if let Some(icon) = icon {
                     icon(ui, openness, &icon_response);
                 } else {
@@ -598,23 +599,13 @@ impl CollapsingHeader {
         ui: &mut Ui,
         add_body: impl FnOnce(&mut Ui) -> R,
     ) -> CollapsingResponse<R> {
-        self.show_dyn(ui, Box::new(add_body), true)
+        self.show_dyn(ui, Box::new(add_body))
-    }
-
-    #[inline]
-    pub fn show_unindented<R>(
-        self,
-        ui: &mut Ui,
-        add_body: impl FnOnce(&mut Ui) -> R,
-    ) -> CollapsingResponse<R> {
-        self.show_dyn(ui, Box::new(add_body), false)
     }
 
     fn show_dyn<'c, R>(
         self,
         ui: &mut Ui,
         add_body: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
-        indented: bool,
     ) -> CollapsingResponse<R> {
         // Make sure body is bellow header,
         // and make sure it is one unit (necessary for putting a [`CollapsingHeader`] in a grid).
@@ -627,11 +618,7 @@ impl CollapsingHeader {
                 openness,
             } = self.begin(ui); // show the header
 
-            let ret_response = if indented {
+            let ret_response = state.show_body_indented(&header_response, ui, add_body);
-                state.show_body_indented(&header_response, ui, add_body)
-            } else {
-                state.show_body_unindented(ui, add_body)
-            };
 
             if let Some(ret_response) = ret_response {
                 CollapsingResponse {

egui/src/containers/combo_box.rs

@@ -1,16 +1,8 @@
+use crate::{style::WidgetVisuals, *};
 use epaint::Shape;
 
-use crate::{style::WidgetVisuals, *};
-
-/// Indicate wether or not a popup will be shown above or below the box.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum AboveOrBelow {
-    Above,
-    Below,
-}
-
 /// A function that paints the [`ComboBox`] icon
-pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBelow)>;
+pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool)>;
 
 /// A drop-down selection menu with a descriptive label.
 ///
@@ -36,7 +28,6 @@ pub struct ComboBox {
     selected_text: WidgetText,
     width: Option<f32>,
     icon: Option<IconPainter>,
-    wrap_enabled: bool,
 }
 
 impl ComboBox {
@@ -48,7 +39,6 @@ impl ComboBox {
             selected_text: Default::default(),
             width: None,
             icon: None,
-            wrap_enabled: false,
         }
     }
 
@@ -61,7 +51,6 @@ impl ComboBox {
             selected_text: Default::default(),
             width: None,
             icon: None,
-            wrap_enabled: false,
         }
     }
 
@@ -73,11 +62,10 @@ impl ComboBox {
             selected_text: Default::default(),
             width: None,
             icon: None,
-            wrap_enabled: false,
         }
     }
 
-    /// Set the outer width of the button and menu.
+    /// Set the width of the button and menu
     pub fn width(mut self, width: f32) -> Self {
         self.width = Some(width);
         self
@@ -101,11 +89,10 @@ impl ComboBox {
     ///     rect: egui::Rect,
     ///     visuals: &egui::style::WidgetVisuals,
     ///     _is_open: bool,
-    ///     _above_or_below: egui::AboveOrBelow,
     /// ) {
     ///     let rect = egui::Rect::from_center_size(
     ///         rect.center(),
-    ///         egui::vec2(rect.width() * 0.6, rect.height() * 0.4),
+    ///         egui::Vec2::new(rect.width() * 0.6, rect.height() * 0.4),
     ///     );
     ///     ui.painter().add(egui::Shape::convex_polygon(
     ///         vec![rect.left_top(), rect.right_top(), rect.center_bottom()],
@@ -120,20 +107,11 @@ impl ComboBox {
     ///     .show_ui(ui, |_ui| {});
     /// # });
     /// ```
-    pub fn icon(
+    pub fn icon(mut self, icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, bool) + 'static) -> Self {
-        mut self,
-        icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBelow) + 'static,
-    ) -> Self {
         self.icon = Some(Box::new(icon_fn));
         self
     }
 
-    /// Controls whether text wrap is used for the selected text
-    pub fn wrap(mut self, wrap: bool) -> Self {
-        self.wrap_enabled = wrap;
-        self
-    }
-
     /// Show the combo box, with the given ui code for the menu contents.
     ///
     /// Returns `InnerResponse { inner: None }` if the combo box is closed.
@@ -156,21 +134,15 @@ impl ComboBox {
             selected_text,
             width,
             icon,
-            wrap_enabled,
         } = self;
 
         let button_id = ui.make_persistent_id(id_source);
 
         ui.horizontal(|ui| {
-            let mut ir = combo_box_dyn(
+            if let Some(width) = width {
-                ui,
+                ui.spacing_mut().slider_width = width; // yes, this is ugly. Will remove later.
-                button_id,
+            }
-                selected_text,
+            let mut ir = combo_box_dyn(ui, button_id, selected_text, menu_contents, icon);
-                menu_contents,
-                icon,
-                wrap_enabled,
-                width,
-            );
             if let Some(label) = label {
                 ir.response
                     .widget_info(|| WidgetInfo::labeled(WidgetType::ComboBox, label.text()));
@@ -237,59 +209,18 @@ fn combo_box_dyn<'c, R>(
     selected_text: WidgetText,
     menu_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     icon: Option<IconPainter>,
-    wrap_enabled: bool,
-    width: Option<f32>,
 ) -> InnerResponse<Option<R>> {
     let popup_id = button_id.with("popup");
 
-    let is_popup_open = ui.memory(|m| m.is_popup_open(popup_id));
+    let is_popup_open = ui.memory().is_popup_open(popup_id);
-
-    let popup_height = ui.memory(|m| m.areas.get(popup_id).map_or(100.0, |state| state.size.y));
-
-    let above_or_below =
-        if ui.next_widget_position().y + ui.spacing().interact_size.y + popup_height
-            < ui.ctx().screen_rect().bottom()
-        {
-            AboveOrBelow::Below
-        } else {
-            AboveOrBelow::Above
-        };
-
-    let margin = ui.spacing().button_padding;
     let button_response = button_frame(ui, button_id, is_popup_open, Sense::click(), |ui| {
-        let icon_spacing = ui.spacing().icon_spacing;
         // We don't want to change width when user selects something new
-        let full_minimum_width = if wrap_enabled {
+        let full_minimum_width = ui.spacing().slider_width;
-            // Currently selected value's text will be wrapped if needed, so occupy the available width.
-            ui.available_width()
-        } else {
-            // Occupy at least the minimum width assigned to ComboBox.
-            let width = width.unwrap_or_else(|| ui.spacing().combo_width);
-            width - 2.0 * margin.x
-        };
         let icon_size = Vec2::splat(ui.spacing().icon_width);
-        let wrap_width = if wrap_enabled {
-            // Use the available width, currently selected value's text will be wrapped if exceeds this value.
-            ui.available_width() - icon_spacing - icon_size.x
-        } else {
-            // Use all the width necessary to display the currently selected value's text.
-            f32::INFINITY
-        };
 
-        let galley =
+        let galley = selected_text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button);
-            selected_text.into_galley(ui, Some(wrap_enabled), wrap_width, TextStyle::Button);
 
-        // The width necessary to contain the whole widget with the currently selected value's text.
+        let width = galley.size().x + ui.spacing().item_spacing.x + icon_size.x;
-        let width = if wrap_enabled {
-            full_minimum_width
-        } else {
-            // Occupy at least the minimum width needed to contain the widget with the currently selected value's text.
-            galley.size().x + icon_spacing + icon_size.x
-        };
-
-        // Case : wrap_enabled : occupy all the available width.
-        // Case : !wrap_enabled : occupy at least the minimum width assigned to Slider and ComboBox,
-        // increase if the currently selected value needs additional horizontal space to fully display its text (up to wrap_width (f32::INFINITY)).
         let width = width.at_least(full_minimum_width);
         let height = galley.size().y.max(icon_size.y);
 
@@ -312,15 +243,9 @@ fn combo_box_dyn<'c, R>(
                     icon_rect.expand(visuals.expansion),
                     visuals,
                     is_popup_open,
-                    above_or_below,
                 );
             } else {
-                paint_default_icon(
+                paint_default_icon(ui.painter(), icon_rect.expand(visuals.expansion), visuals);
-                    ui.painter(),
-                    icon_rect.expand(visuals.expansion),
-                    visuals,
-                    above_or_below,
-                );
             }
 
             let text_rect = Align2::LEFT_CENTER.align_size_within_rect(galley.size(), rect);
@@ -329,20 +254,14 @@ fn combo_box_dyn<'c, R>(
     });
 
     if button_response.clicked() {
-        ui.memory_mut(|mem| mem.toggle_popup(popup_id));
+        ui.memory().toggle_popup(popup_id);
     }
-    let inner = crate::popup::popup_above_or_below_widget(
+    let inner = crate::popup::popup_below_widget(ui, popup_id, &button_response, |ui| {
-        ui,
-        popup_id,
-        &button_response,
-        above_or_below,
-        |ui| {
         ScrollArea::vertical()
             .max_height(ui.spacing().combo_height)
             .show(ui, menu_contents)
             .inner
-        },
+    });
-    );
 
     InnerResponse {
         inner,
@@ -386,7 +305,7 @@ fn button_frame(
             epaint::RectShape {
                 rect: outer_rect.expand(visuals.expansion),
                 rounding: visuals.rounding,
-                fill: visuals.weak_bg_fill,
+                fill: visuals.bg_fill,
                 stroke: visuals.bg_stroke,
             },
         );
@@ -397,33 +316,13 @@ fn button_frame(
     response
 }
 
-fn paint_default_icon(
+fn paint_default_icon(painter: &Painter, rect: Rect, visuals: &WidgetVisuals) {
-    painter: &Painter,
-    rect: Rect,
-    visuals: &WidgetVisuals,
-    above_or_below: AboveOrBelow,
-) {
     let rect = Rect::from_center_size(
         rect.center(),
         vec2(rect.width() * 0.7, rect.height() * 0.45),
     );
-
+    painter.add(Shape::closed_line(
-    match above_or_below {
-        AboveOrBelow::Above => {
-            // Upward pointing triangle
-            painter.add(Shape::convex_polygon(
-                vec![rect.left_bottom(), rect.right_bottom(), rect.center_top()],
-                visuals.fg_stroke.color,
-                Stroke::NONE,
-            ));
-        }
-        AboveOrBelow::Below => {
-            // Downward pointing triangle
-            painter.add(Shape::convex_polygon(
         vec![rect.left_top(), rect.right_top(), rect.center_bottom()],
-                visuals.fg_stroke.color,
+        visuals.fg_stroke,
-                Stroke::NONE,
     ));
-        }
-    }
 }

egui/src/containers/frame.rs

@@ -19,16 +19,11 @@ use epaint::*;
 pub struct Frame {
     /// Margin within the painted frame.
     pub inner_margin: Margin,
-
     /// Margin outside the painted frame.
     pub outer_margin: Margin,
-
     pub rounding: Rounding,
-
     pub shadow: Shadow,
-
     pub fill: Color32,
-
     pub stroke: Stroke,
 }
 
@@ -47,18 +42,22 @@ impl Frame {
         }
     }
 
-    pub fn side_top_panel(style: &Style) -> Self {
+    pub(crate) fn side_top_panel(style: &Style) -> Self {
         Self {
             inner_margin: Margin::symmetric(8.0, 2.0),
-            fill: style.visuals.panel_fill,
+            rounding: Rounding::none(),
+            fill: style.visuals.window_fill(),
+            stroke: style.visuals.window_stroke(),
             ..Default::default()
         }
     }
 
-    pub fn central_panel(style: &Style) -> Self {
+    pub(crate) fn central_panel(style: &Style) -> Self {
         Self {
             inner_margin: Margin::same(8.0),
-            fill: style.visuals.panel_fill,
+            rounding: Rounding::none(),
+            fill: style.visuals.window_fill(),
+            stroke: Default::default(),
             ..Default::default()
         }
     }
@@ -76,8 +75,8 @@ impl Frame {
 
     pub fn menu(style: &Style) -> Self {
         Self {
-            inner_margin: style.spacing.menu_margin,
+            inner_margin: Margin::same(1.0),
-            rounding: style.visuals.menu_rounding,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             shadow: style.visuals.popup_shadow,
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
@@ -87,8 +86,8 @@ impl Frame {
 
     pub fn popup(style: &Style) -> Self {
         Self {
-            inner_margin: style.spacing.menu_margin,
+            inner_margin: style.spacing.window_margin,
-            rounding: style.visuals.menu_rounding,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             shadow: style.visuals.popup_shadow,
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
@@ -120,45 +119,38 @@ impl Frame {
 }
 
 impl Frame {
-    #[inline]
     pub fn fill(mut self, fill: Color32) -> Self {
         self.fill = fill;
         self
     }
 
-    #[inline]
     pub fn stroke(mut self, stroke: Stroke) -> Self {
         self.stroke = stroke;
         self
     }
 
-    #[inline]
     pub fn rounding(mut self, rounding: impl Into<Rounding>) -> Self {
         self.rounding = rounding.into();
         self
     }
 
     /// Margin within the painted frame.
-    #[inline]
     pub fn inner_margin(mut self, inner_margin: impl Into<Margin>) -> Self {
         self.inner_margin = inner_margin.into();
         self
     }
 
     /// Margin outside the painted frame.
-    #[inline]
     pub fn outer_margin(mut self, outer_margin: impl Into<Margin>) -> Self {
         self.outer_margin = outer_margin.into();
         self
     }
 
     #[deprecated = "Renamed inner_margin in egui 0.18"]
-    #[inline]
     pub fn margin(self, margin: impl Into<Margin>) -> Self {
         self.inner_margin(margin)
     }
 
-    #[inline]
     pub fn shadow(mut self, shadow: Shadow) -> Self {
         self.shadow = shadow;
         self
@@ -172,16 +164,6 @@ impl Frame {
     }
 }
 
-impl Frame {
-    /// inner margin plus outer margin.
-    #[inline]
-    pub fn total_margin(&self) -> Margin {
-        self.inner_margin + self.outer_margin
-    }
-}
-
-// ----------------------------------------------------------------------------
-
 pub struct Prepared {
     pub frame: Frame,
     where_to_put_background: ShapeIdx,
@@ -262,13 +244,6 @@ impl Prepared {
         rect
     }
 
-    fn content_with_margin(&self) -> Rect {
-        let mut rect = self.content_ui.min_rect();
-        rect.min -= self.frame.inner_margin.left_top() + self.frame.outer_margin.left_top();
-        rect.max += self.frame.inner_margin.right_bottom() + self.frame.outer_margin.right_bottom();
-        rect
-    }
-
     pub fn end(self, ui: &mut Ui) -> Response {
         let paint_rect = self.paint_rect();
 
@@ -283,6 +258,6 @@ impl Prepared {
             ui.painter().set(where_to_put_background, shape);
         }
 
-        ui.allocate_rect(self.content_with_margin(), Sense::hover())
+        ui.allocate_rect(paint_rect, Sense::hover())
     }
 }