update eframe and fix web build

Author: vdrn

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_graph"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2024"
 authors = ["Vedran Maric <valinion@gmail.com>"]
 description = "Graphing calculator with f32 support."
@@ -34,29 +34,29 @@ inherits = "release"
 lto = "thin"
 
 [dependencies]
-eframe = { version = "0.33",features=[
+eframe = { version = "0.34",features=[
     "accesskit",
     "default_fonts",
     "wayland",
     "web_screen_reader",
     "x11",
 "persistence", "wgpu"] }
-wgpu = { version = "*", features = [ "webgpu", "webgl", "vulkan", "metal", "dx12", "gles", "wgsl", ] } # profiling = {version="1.0", features=["profile-with-puffin"]}
+wgpu = { version = "29", features = [ "webgpu", "webgl", "vulkan", "metal", "gles", "wgsl", ] }
 bytemuck = "1"
 cfg-if = "1"
-egui_plot="0.34"
+egui_plot="0.35"
 send_wrapper = "0.6"
-egui-file-dialog ="0.12"
+egui-file-dialog ="0.13"
 # enum-map="2.7"
-
+web-time = "1"
 # egui_extras={version = "0.33", features=["syntect"]}
 # syntect = { version = "5.3", default-features = false, features = ["default-fancy"]}
 evalexpr = { path = "evalexpr" }
 
 rustc-hash = "2"
 serde = { version = "1" }
 serde_json = "1"
-egui_dnd="0.14"
+egui_dnd="0.15"
 bincode={version="2", features=["serde"]}
 base64="0.22"
 arrayvec = "0.7"
@@ -75,8 +75,8 @@ getrandom = { version = "0.3", features = ["wasm_js"] }
 # puffin_http = { path = "../../contrib/puffin/puffin_http" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-puffin = { version = "0.19", optional = true }
-puffin_http = { version = "0.16", optional = true }
+puffin = { version = "0.20", optional = true }
+puffin_http = { version = "0.17", optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-futures = "0.4"

Cargo.toml

@@ -1,7 +1,6 @@
 # Rust Graph
 Desmos-like graphing calculator with support for f32 numbers.
 
-
 ## Use it online
 
 [Web Demo](https://rust-graph.netlify.app/)
@@ -21,3 +20,4 @@ cargo install --git https://github.com/vdrn/rust_graph
 
 
 
+

README.md

@@ -1,6 +1,4 @@
 [toolchain]
-# 10-02 good
-# 10-03 bad
 channel = "nightly-2025-11-15"
 components = ["rust-src", "rust-analyzer", "clippy", "rustfmt"]
 targets = ["wasm32-unknown-unknown"]

examples/Riemann zeta function.json

@@ -68,14 +68,14 @@ impl FanFillRenderer {
 		});
 
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-			label:                Some("fan_pipeline_layout"),
-			bind_group_layouts:   &[&bind_group_layout],
-			push_constant_ranges: &[],
+			label:              Some("fan_pipeline_layout"),
+			bind_group_layouts: &[Some(&bind_group_layout)],
+			immediate_size:     0,
 		});
 		let mut stencil_pipeline_descriptor = wgpu::RenderPipelineDescriptor {
-			label:         Some("stencil_pipeline"),
-			layout:        Some(&pipeline_layout),
-			vertex:        wgpu::VertexState {
+			label:          Some("stencil_pipeline"),
+			layout:         Some(&pipeline_layout),
+			vertex:         wgpu::VertexState {
 				module:              &shader,
 				entry_point:         Some("vs_main"),
 				buffers:             &[wgpu::VertexBufferLayout {
@@ -89,12 +89,12 @@ impl FanFillRenderer {
 				}],
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 			},
-			fragment:      None, // No color output in stencil pass
-			primitive:     wgpu::PrimitiveState::default(),
-			depth_stencil: Some(wgpu::DepthStencilState {
+			fragment:       None, // No color output in stencil pass
+			primitive:      wgpu::PrimitiveState::default(),
+			depth_stencil:  Some(wgpu::DepthStencilState {
 				format:              wgpu::TextureFormat::Stencil8,
-				depth_write_enabled: false,
-				depth_compare:       wgpu::CompareFunction::Always,
+				depth_write_enabled: Some(false),
+				depth_compare:       Some(wgpu::CompareFunction::Always),
 				stencil:             wgpu::StencilState {
 					front:      wgpu::StencilFaceState {
 						compare:       wgpu::CompareFunction::Always,
@@ -113,16 +113,16 @@ impl FanFillRenderer {
 				},
 				bias:                wgpu::DepthBiasState::default(),
 			}),
-			multisample:   wgpu::MultisampleState::default(),
-			multiview:     None,
-			cache:         None,
+			multisample:    wgpu::MultisampleState::default(),
+			multiview_mask: None,
+			cache:          None,
 		};
 		let even_odd_stencil_pipeline = device.create_render_pipeline(&stencil_pipeline_descriptor);
 
 		stencil_pipeline_descriptor.depth_stencil = Some(wgpu::DepthStencilState {
 			format:              wgpu::TextureFormat::Stencil8,
-			depth_write_enabled: false,
-			depth_compare:       wgpu::CompareFunction::Always,
+			depth_write_enabled: Some(false),
+			depth_compare:       Some(wgpu::CompareFunction::Always),
 			stencil:             wgpu::StencilState {
 				front:      wgpu::StencilFaceState {
 					compare:       wgpu::CompareFunction::Always,
@@ -144,15 +144,15 @@ impl FanFillRenderer {
 		let non_zero_stencil_pipeline = device.create_render_pipeline(&stencil_pipeline_descriptor);
 
 		let color_pipeline_descriptor = wgpu::RenderPipelineDescriptor {
-			label:         Some("color_pipeline"),
-			layout:        Some(&pipeline_layout),
-			vertex:        wgpu::VertexState {
+			label:          Some("color_pipeline"),
+			layout:         Some(&pipeline_layout),
+			vertex:         wgpu::VertexState {
 				module:              &shader,
 				entry_point:         Some("vs_quad"),
 				buffers:             &[],
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 			},
-			fragment:      Some(wgpu::FragmentState {
+			fragment:       Some(wgpu::FragmentState {
 				module:              &shader,
 				entry_point:         Some("fs_quad"),
 				targets:             &[Some(wgpu::ColorTargetState {
@@ -162,11 +162,11 @@ impl FanFillRenderer {
 				})],
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 			}),
-			primitive:     wgpu::PrimitiveState::default(),
-			depth_stencil: Some(wgpu::DepthStencilState {
+			primitive:      wgpu::PrimitiveState::default(),
+			depth_stencil:  Some(wgpu::DepthStencilState {
 				format:              wgpu::TextureFormat::Stencil8,
-				depth_write_enabled: false,
-				depth_compare:       wgpu::CompareFunction::Always,
+				depth_write_enabled: Some(false),
+				depth_compare:       Some(wgpu::CompareFunction::Always),
 				stencil:             wgpu::StencilState {
 					front:      wgpu::StencilFaceState {
 						compare:       wgpu::CompareFunction::NotEqual,
@@ -185,9 +185,9 @@ impl FanFillRenderer {
 				},
 				bias:                wgpu::DepthBiasState::default(),
 			}),
-			multisample:   wgpu::MultisampleState::default(),
-			multiview:     None,
-			cache:         None,
+			multisample:    wgpu::MultisampleState::default(),
+			multiview_mask: None,
+			cache:          None,
 		};
 		let color_pipeline = device.create_render_pipeline(&color_pipeline_descriptor);
 
@@ -399,6 +399,7 @@ impl FanFillRenderer {
 				}),
 				timestamp_writes:         None,
 				occlusion_query_set:      None,
+				multiview_mask:           None,
 			});
 
 			match fill_rule {
@@ -439,6 +440,7 @@ impl FanFillRenderer {
 				}),
 				timestamp_writes:         None,
 				occlusion_query_set:      None,
+				multiview_mask:           None,
 			});
 
 			color_pass.set_pipeline(&resources.color_pipeline);

.rust-toolchain.toml rust-toolchain.toml.rust-toolchain.toml renamed to rust-toolchain.toml

@@ -24,22 +24,23 @@ pub fn init_mesh_renderer(cc: &eframe::CreationContext) -> Option<()> {
 			ty:         wgpu::BindingType::Buffer {
 				ty:                 wgpu::BufferBindingType::Uniform,
 				has_dynamic_offset: false,
-				min_binding_size:   NonZeroU64::new(24), // screen_size + rect(x, y, width, height)
+				min_binding_size:   NonZeroU64::new(32), /* screen_size + rect(x, y, width, height) + 8
+				                                          * byte padding */
 			},
 			count:      None,
 		}],
 	});
 
 	let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-		label:                Some("mesh_renderer"),
-		bind_group_layouts:   &[&bind_group_layout],
-		push_constant_ranges: &[],
+		label:              Some("mesh_renderer"),
+		bind_group_layouts: &[Some(&bind_group_layout)],
+		immediate_size:     0,
 	});
 
 	let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-		label:         Some("mesh_renderer"),
-		layout:        Some(&pipeline_layout),
-		vertex:        wgpu::VertexState {
+		label:          Some("mesh_renderer"),
+		layout:         Some(&pipeline_layout),
+		vertex:         wgpu::VertexState {
 			module:              &shader,
 			entry_point:         None,
 			buffers:             &[wgpu::VertexBufferLayout {
@@ -68,7 +69,7 @@ pub fn init_mesh_renderer(cc: &eframe::CreationContext) -> Option<()> {
 			}],
 			compilation_options: wgpu::PipelineCompilationOptions::default(),
 		},
-		fragment:      Some(wgpu::FragmentState {
+		fragment:       Some(wgpu::FragmentState {
 			module:              &shader,
 			entry_point:         Some("fs_main"),
 			targets:             &[Some(wgpu::ColorTargetState {
@@ -78,19 +79,19 @@ pub fn init_mesh_renderer(cc: &eframe::CreationContext) -> Option<()> {
 			})],
 			compilation_options: wgpu::PipelineCompilationOptions::default(),
 		}),
-		primitive:     wgpu::PrimitiveState {
+		primitive:      wgpu::PrimitiveState {
 			topology: wgpu::PrimitiveTopology::TriangleList,
 			..Default::default()
 		},
-		depth_stencil: None,
-		multisample:   wgpu::MultisampleState::default(),
-		multiview:     None,
-		cache:         None,
+		depth_stencil:  None,
+		multisample:    wgpu::MultisampleState::default(),
+		multiview_mask: None,
+		cache:          None,
 	});
 
 	let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 		label:    Some("mesh_renderer_uniform"),
-		contents: bytemuck::cast_slice(&[0.0_f32; 6]),
+		contents: bytemuck::cast_slice(&[0.0_f32; 8]),
 		usage:    wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
 	});
 
@@ -165,6 +166,8 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 				self.frame.min.y,
 				self.frame.width(),
 				self.frame.height(),
+				0.0,
+				0.0,
 			];
 			queue.write_buffer(&mesh_resources.uniform_buffer, 0, bytemuck::cast_slice(&uniforms));
 		}

src/custom_rendering/fan_fill_renderer.rs

@@ -2,6 +2,7 @@ struct Locals {
     screen_size: vec2<f32>,
     rect_min: vec2<f32>,
     rect_size: vec2<f32>,
+    padding: vec2<f32>,
 }
 
 @group(0) @binding(0)

src/custom_rendering/mesh_renderer.rs

@@ -549,12 +549,12 @@ fn inline_and_fold_entry<T: EvalexprFloat>(
 			let Some(node) = &func.node else {
 				return Ok(());
 			};
-			println!("node: {identifier}: {:#?}", node);
+			// println!("node: {identifier}: {:#?}", node);
 			let inlined_node = evalexpr::optimize_flat_node(node, ctx).map_err(|e| e.to_string())?;
-			println!("inlined node {identifier}: {:#?}", inlined_node);
+			// println!("inlined node {identifier}: {:#?}", inlined_node);
 			let expr_function = ExpressionFunction::new(inlined_node, &func.args, &mut Some(ctx))
 				.map_err(|e| e.to_string())?;
-			println!("expr_func node: {identifier} {:#?}", expr_function);
+			// println!("expr_func node: {identifier} {:#?}", expr_function);
 
 			if identifier.to_str() != "" && func.equation_type == EquationType::None {
 				ctx.set_expression_function(*identifier, expr_function.clone());

src/custom_rendering/mesh_shader.wgsl

@@ -231,7 +231,6 @@ pub fn graph_ui<T: evalexpr::EvalexprFloat>(
 
 		if ui_state.reset_graph {
 			force_create_elements = true;
-			ui_state.reset_graph = false;
 			state.graph_state.current_graph_config = state.graph_state.saved_graph_config.clone();
 		}
 
@@ -260,6 +259,10 @@ pub fn graph_ui<T: evalexpr::EvalexprFloat>(
 			.clamp_grid(graph_conf.clamp_grid)
 			.grid_spacing(graph_conf.grid_spacing.0..=graph_conf.grid_spacing.1);
 
+		if ui_state.reset_graph {
+			plot = plot.reset();
+			ui_state.reset_graph = false;
+		}
 		plot = plot
 			.default_x_bounds(calcd_bounds.min()[0], calcd_bounds.max()[0])
 			.default_y_bounds(calcd_bounds.min()[1], calcd_bounds.max()[1]);