Basic EGUI integration

Cargo.lock

···
 ]
 
 [[package]]
+name = "arboard"
+version = "3.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df099ccb16cd014ff054ac1bf392c67feeef57164b05c42f037cd40f5d4357f4"
+dependencies = [
+ "clipboard-win",
+ "core-graphics",
+ "image",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "parking_lot",
+ "windows-sys 0.48.0",
+ "x11rb",
+]
+
+[[package]]
 name = "arrayref"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "cfg-if",
  "console_error_panic_hook",
  "console_log",
+ "egui",
+ "egui-wgpu",
+ "egui-winit",
  "env_logger",
  "fs_extra",
  "futures",
···
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "clipboard-win"
+version = "5.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15efe7a882b08f34e38556b14f2fb3daa98769d06c7f0c1b076dfd0d983bc892"
+dependencies = [
+ "error-code",
+]
 
 [[package]]
 name = "codespan-reporting"
···
 ]
 
 [[package]]
+name = "core-foundation"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-graphics-types",
  "foreign-types 0.5.0",
  "libc",
···
 checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "libc",
 ]
 
···
 checksum = "f25c0e292a7ca6d6498557ff1df68f32c99850012b6ea401cf8daf771f22ff53"
 
 [[package]]
+name = "ecolor"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "878e9005799dd739e5d5d89ff7480491c12d0af571d44399bcaefa1ee172dd76"
+dependencies = [
+ "bytemuck",
+ "emath",
+]
+
+[[package]]
+name = "egui"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d2768eaa6d5c80a6e2a008da1f0e062dff3c83eb2b28605ea2d0732d46e74d6"
+dependencies = [
+ "ahash",
+ "bitflags 2.8.0",
+ "emath",
+ "epaint",
+ "log",
+ "nohash-hasher",
+ "profiling",
+]
+
+[[package]]
+name = "egui-wgpu"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d8151704bcef6271bec1806c51544d70e79ef20e8616e5eac01facfd9c8c54a"
+dependencies = [
+ "ahash",
+ "bytemuck",
+ "document-features",
+ "egui",
+ "epaint",
+ "log",
+ "profiling",
+ "thiserror 1.0.69",
+ "type-map",
+ "web-time",
+ "wgpu",
+]
+
+[[package]]
+name = "egui-winit"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace791b367c1f63e6044aef2f3834904509d1d1a6912fd23ebf3f6a9af92cd84"
+dependencies = [
+ "ahash",
+ "arboard",
+ "bytemuck",
+ "egui",
+ "log",
+ "profiling",
+ "raw-window-handle",
+ "smithay-clipboard",
+ "web-time",
+ "webbrowser",
+ "winit",
+]
+
+[[package]]
 name = "either"
 version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
+[[package]]
+name = "emath"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55b7b6be5ad1d247f11738b0e4699d9c20005ed366f2c29f5ec1f8e1de180bc2"
+dependencies = [
+ "bytemuck",
+]
 
 [[package]]
 name = "encoding_rs"
···
 ]
 
 [[package]]
+name = "epaint"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "275b665a7b9611d8317485187e5458750850f9e64604d3c58434bb3fc1d22915"
+dependencies = [
+ "ab_glyph",
+ "ahash",
+ "bytemuck",
+ "ecolor",
+ "emath",
+ "epaint_default_fonts",
+ "log",
+ "nohash-hasher",
+ "parking_lot",
+ "profiling",
+]
+
+[[package]]
+name = "epaint_default_fonts"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9343d356d7cac894dacafc161b4654e0881301097bdf32a122ed503d97cb94b6"
+
+[[package]]
 name = "equivalent"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "libc",
  "windows-sys 0.59.0",
 ]
+
+[[package]]
+name = "error-code"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d9305ccc6942a704f4335694ecd3de2ea531b114ac2d51f5f843750787a92f"
 
 [[package]]
 name = "fastrand"
···
 checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
+name = "home"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "http"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "byteorder-lite",
  "num-traits",
  "png",
+ "tiff",
  "zune-core",
  "zune-jpeg",
 ]
···
 ]
 
 [[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
+[[package]]
 name = "js-sys"
 version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "jni-sys",
 ]
+
+[[package]]
+name = "nohash-hasher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
 [[package]]
 name = "num-traits"
···
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
  "bitflags 2.8.0",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
···
 ]
 
 [[package]]
+name = "smithay-clipboard"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc8216eec463674a0e90f29e0ae41a4db573ec5b56b1c6c1c71615d249b6d846"
+dependencies = [
+ "libc",
+ "smithay-client-toolkit",
+ "wayland-backend",
+]
+
+[[package]]
 name = "smol_str"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
  "bitflags 2.8.0",
- "core-foundation",
+ "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
 
···
  "proc-macro2",
  "quote",
  "syn",
+]
+
+[[package]]
+name = "tiff"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
+dependencies = [
+ "flate2",
+ "jpeg-decoder",
+ "weezl",
 ]
 
 [[package]]
···
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
 
 [[package]]
+name = "type-map"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
+dependencies = [
+ "rustc-hash",
+]
+
+[[package]]
 name = "unicode-ident"
 version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "webbrowser"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea9fe1ebb156110ff855242c1101df158b822487e4957b0556d9ffce9db0f535"
+dependencies = [
+ "block2",
+ "core-foundation 0.10.0",
+ "home",
+ "jni",
+ "log",
+ "ndk-context",
+ "objc2",
+ "objc2-foundation",
+ "url",
+ "web-sys",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+
+[[package]]
 name = "wgpu"
 version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
  "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
···
  "calloop",
  "cfg_aliases",
  "concurrent-queue",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-graphics",
  "cursor-icon",
  "dpi",

Cargo.toml

···
 tobj = { version = "4", default-features = false, features = ["async"] }
 futures = "0.3"
 itertools = "0.14"
+egui = "0.31"
+egui-wgpu = "0.31"
+egui-winit = "0.31"
 
 [build-dependencies]
 fs_extra = "1.3"

src/app.rs

···
-use crate::gfx::{Gfx, GfxBuilder, MaybeGfx};
+use crate::{
+    gfx::{Gfx, GfxBuilder, MaybeGfx},
+    gui::EguiRenderer,
+};
 use std::sync::Arc;
 use winit::{
     application::ApplicationHandler,
···
     window_attributes: WindowAttributes,
     gfx_state: MaybeGfx,
     window: Option<Arc<Window>>,
+    egui: Option<EguiRenderer>,
 }
 
 impl Application {
···
             window_attributes: Window::default_attributes().with_title(title),
             gfx_state: MaybeGfx::Builder(GfxBuilder::new(event_loop.create_proxy())),
             window: None,
+            egui: None,
         }
     }
 }
···
     }
 
     fn user_event(&mut self, _event_loop: &ActiveEventLoop, gfx: Gfx) {
+        if let Some(window) = &self.window {
+            let egui = EguiRenderer::new(&gfx.device, gfx.surface_config.format, None, 1, window);
+            self.egui = Some(egui);
+        }
         self.gfx_state = MaybeGfx::Graphics(gfx);
     }
 
···
         };
 
         if let Some(ref window) = &self.window {
+            // Returns true if EGUI consumes the input.
+            if self
+                .egui
+                .as_mut()
+                .map(|egui| egui.handle_input(window, &event))
+                .is_some_and(|x| x)
+            {
+                return;
+            }
+
             gfx.input(&event, window.inner_size());
         }
 
···
                 // Some horrible nesting here! Don't tell Linus...
                 if let Some(ref window) = &self.window {
                     window.request_redraw();
-                    match gfx.render() {
+                    match gfx.render(&mut self.egui, window.clone()) {
                         Ok(_) => {
+                            // TODO CITE https://github.com/kaphula/winit-egui-wgpu-template/blob/master/src/app.rs#L3
                             gfx.update();
                         }
                         Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {

src/gfx.rs

···
 
 use std::sync::Arc;
 
+use egui_wgpu::ScreenDescriptor;
 use glam::{vec3, Quat, Vec3};
 use wgpu::util::DeviceExt;
 use winit::{
···
     window::Window,
 };
 
-use crate::{app::WASM_WIN_SIZE, gfx::model::Vertex, map::{sl3get, Block, CHUNK_SIZE}, Instance, InstanceRaw};
+use crate::{
+    app::WASM_WIN_SIZE,
+    gfx::model::Vertex,
+    gui::EguiRenderer,
+    map::{sl3get, Block, CHUNK_SIZE},
+    Instance, InstanceRaw,
+};
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
···
     bind_group: wgpu::BindGroup,
 }
 
-struct RenderPipelines {
+pub struct RenderPipelines {
     camera: wgpu::RenderPipeline,
     camera_wireframe: Option<wgpu::RenderPipeline>,
     light: wgpu::RenderPipeline,
···
 }
 
 pub struct Gfx {
-    surface: wgpu::Surface<'static>,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
-    surface_config: wgpu::SurfaceConfiguration,
-    render_pipelines: RenderPipelines,
-    depth_texture: texture::Texture,
+    pub surface: wgpu::Surface<'static>,
+    pub device: wgpu::Device,
+    pub queue: wgpu::Queue,
+    pub surface_config: wgpu::SurfaceConfiguration,
+    pub render_pipelines: RenderPipelines,
+    pub depth_texture: texture::Texture,
 
     object: ObjectState,
     camera: CameraState,
···
                 label: Some("texture_bind_group_layout"),
             });
 
-
         let camera = camera::Camera {
             eye: vec3(50., 20., 50.),
             target: Vec3::ZERO,
···
         for (coords, chunk) in map.chunks {
             let _3diter = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2);
 
-            let mut i = _3diter.filter_map(|(x,y,z)| {
+            let mut i = _3diter
+                .filter_map(|(x, y, z)| {
+                    if let Block::Air = sl3get(&chunk.blocks, x, y, z) {
+                        return None;
+                    }
 
-                if let Block::AIR = sl3get(&chunk.blocks, x, y, z) {
-                    return None;
-                }
+                    let chunk_offset = coords.as_vec2() * (SPACE_BETWEEN * CHUNK_SIZE.0 as f32);
 
-                let chunk_offset = coords.as_vec2() * (SPACE_BETWEEN * CHUNK_SIZE.0 as f32);
+                    let mapping = |n| SPACE_BETWEEN * (n as f32 - CHUNK_SIZE.0 as f32 / 2.0);
+                    let position = vec3(
+                        mapping(x) + chunk_offset.x,
+                        -mapping(y),
+                        mapping(z) + chunk_offset.y,
+                    );
 
-                let mapping = |n| SPACE_BETWEEN * (n as f32 - CHUNK_SIZE.0 as f32 / 2.0);
-                let position = vec3(mapping(x) + chunk_offset.x, -mapping(y), mapping(z) + chunk_offset.y);
+                    // this is needed so an object at (0, 0, 0) won't get scaled to zero
+                    // as Quaternions can affect scale if they're not created correctly
+                    // let rotation = match position.try_normalize() {
+                    //     Some(position) => Quat::from_axis_angle(position, 45.0),
+                    //     _ => Quat::from_axis_angle(Vec3::Z, 0.0),
+                    // };
+                    let rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
 
-                // this is needed so an object at (0, 0, 0) won't get scaled to zero
-                // as Quaternions can affect scale if they're not created correctly
-                // let rotation = match position.try_normalize() {
-                //     Some(position) => Quat::from_axis_angle(position, 45.0),
-                //     _ => Quat::from_axis_angle(Vec3::Z, 0.0),
-                // };
-                let rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
-
-                Some(Instance { position, rotation })
-
-            }).collect::<Vec<_>>();
+                    Some(Instance { position, rotation })
+                })
+                .collect::<Vec<_>>();
 
             instances.append(&mut i);
         }
···
             usage: wgpu::BufferUsages::VERTEX,
         });
 
-        let obj_model =
-            resources::load_model("blender_default_cube.obj", &device, &queue, &texture_bind_group_layout)
-                .await
-                .unwrap();
+        let obj_model = resources::load_model(
+            "blender_default_cube.obj",
+            &device,
+            &queue,
+            &texture_bind_group_layout,
+        )
+        .await
+        .unwrap();
 
         let light_uniform = LightUniform::new(Vec3::splat(90.0).with_y(40.0), vec3(1.0, 1.0, 0.5));
 
···
         self.surface.configure(&self.device, &self.surface_config);
     }
 
-    pub(crate) fn render(&self) -> Result<(), wgpu::SurfaceError> {
+    pub(crate) fn render(
+        &self,
+        egui: &mut Option<EguiRenderer>,
+        window: Arc<Window>,
+    ) -> Result<(), wgpu::SurfaceError> {
         let output = self.surface.get_current_texture()?;
 
         let view = output
···
             &self.light.bind_group,
         );
 
+
         // drop render pass before we submit to drop the mut borrow on encoder
         drop(render_pass);
+
+        // Layer EGUI on top of frame!
+        if let Some(egui) = egui {
+            let screen_descriptor = ScreenDescriptor {
+                size_in_pixels: [self.surface_config.width, self.surface_config.height],
+                pixels_per_point: window.scale_factor() as f32 * egui.scale_factor,
+            };
+            egui.begin_frame(&window);
+
+            egui.update();
+
+            egui.end_frame_and_draw(
+                &self.device,
+                &self.queue,
+                &mut encoder,
+                &window,
+                &view,
+                screen_descriptor,
+            );
+        }
 
         self.queue.submit(std::iter::once(encoder.finish()));
         output.present();

src/gui.rs

···
+use egui_winit::EventResponse;
+use winit::window::Window;
+
+pub struct EguiRenderer {
+    state: egui_winit::State,
+    renderer: egui_wgpu::Renderer,
+    frame_started: bool,
+    pub scale_factor: f32,
+}
+
+impl EguiRenderer {
+    // Just a helper
+    pub fn ctx(&self) -> &egui::Context {
+        self.state.egui_ctx()
+    }
+
+    pub fn new(
+        device: &wgpu::Device,
+        output_color_format: wgpu::TextureFormat,
+        output_depth_format: Option<wgpu::TextureFormat>,
+        msaa_samples: u32,
+        window: &Window,
+    ) -> EguiRenderer {
+        let context = egui::Context::default();
+        let state = egui_winit::State::new(
+            context,
+            egui::viewport::ViewportId::ROOT,
+            &window,
+            Some(window.scale_factor() as f32),
+            None,
+            Some(2 * 1024), // "max texture side"  of 2048
+        );
+
+        let renderer = egui_wgpu::Renderer::new(
+            device,
+            output_color_format,
+            output_depth_format,
+            msaa_samples,
+            true,
+        );
+
+        EguiRenderer {
+            state,
+            renderer,
+            frame_started: false,
+            scale_factor: 1.0
+        }
+    }
+
+    pub fn handle_input(&mut self, window: &Window, event: &winit::event::WindowEvent) -> bool {
+        let EventResponse {consumed, ..} = self.state.on_window_event(window, event);
+        consumed
+    }
+
+    pub(crate) fn begin_frame(&mut self, window: &Window) {
+        let raw_input = self.state.take_egui_input(window);
+        self.ctx().begin_pass(raw_input);
+        self.frame_started = true;
+    }
+
+    pub(crate) fn end_frame_and_draw(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        window: &Window,
+        surface_view: &wgpu::TextureView,
+        screen_descriptor: egui_wgpu::ScreenDescriptor,
+    ) {
+        if !self.frame_started {
+            panic!("begin_frame must be called before end_frame_and_draw can be called!");
+        }
+
+        self.ctx().set_pixels_per_point(screen_descriptor.pixels_per_point);
+
+        let full_output = self.ctx().end_pass();
+
+        self.state
+            .handle_platform_output(window, full_output.platform_output);
+
+        let tris = self
+            .ctx()
+            .tessellate(full_output.shapes, self.ctx().pixels_per_point());
+
+        for (id, image_delta) in &full_output.textures_delta.set {
+            self.renderer
+                .update_texture(device, queue, *id, image_delta);
+        }
+
+        self.renderer
+            .update_buffers(device, queue, encoder, &tris, &screen_descriptor);
+
+        let render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("EGUI Main Render Pass"),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: surface_view,
+                resolve_target: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
+        });
+
+        self.renderer.render(
+            &mut render_pass.forget_lifetime(),
+            &tris,
+            &screen_descriptor,
+        );
+        for x in &full_output.textures_delta.free {
+            self.renderer.free_texture(x)
+        }
+
+        self.frame_started = false;
+    }
+
+    pub fn update(&mut self) {
+        let ctx = self.ctx();
+
+        let mut scale_factor = self.scale_factor;
+
+        egui::Window::new("winit + egui + wgpu says hello!")
+            .resizable(true)
+            .vscroll(true)
+            .default_open(false)
+            .show(ctx, |ui| {
+                ui.label("Label!");
+
+                if ui.button("Button!").clicked() {
+                    println!("boom!")
+                }
+
+                ui.separator();
+                ui.horizontal(|ui| {
+                    ui.label(format!("Pixels per point: {}", ctx.pixels_per_point()));
+                    if ui.button("-").clicked() {
+                        scale_factor = (scale_factor - 0.1).max(0.3);
+                    }
+                    if ui.button("+").clicked() {
+                        scale_factor = (scale_factor + 0.1).min(3.0);
+                    }
+                });
+            });
+
+        self.scale_factor = scale_factor;
+    }
+}

src/lib.rs

···
 mod app;
 mod gfx;
 mod map;
+mod gui;
 
-use glam::{Mat3, Mat4, Quat, Vec3};
+use glam::{Mat3, Quat, Vec3};
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::UnwrapThrowExt;

src/map.rs

···
 #[repr(u32)]
 pub enum Block {
     #[default]
-    AIR = 0,
-    BRICK,
+    Air = 0,
+    Brick,
 }
 
 fn new_chunk(world_x: i32, world_z: i32) -> Chunk {
···
         // Pretty arbitrary numbers! Just trying to get something interesting
         let n = (((sines / 4. + 0.5) * CHUNK_SIZE.2 as f32).round() as i32) <= y as _;
         sl3set(&mut blocks, x, y, z, {
-            if n { Block::BRICK } else { Block::AIR }
+            if n { Block::Brick } else { Block::Air }
         });
     }