feat: TextNode

Author: zty012

Cargo.lock

@@ -22,6 +22,7 @@ serde_json = "1.0.149"
 typetag = "0.2.21"
 dyn-clone = "1.0.20"
 once_cell = "1.21.3"
+enum_dispatch = "0.3.13"
 
 # 资源处理 (图片与字体)
 image = { version = "0.25.9", features = ["jpeg", "png"] }
@@ -30,6 +31,7 @@ font-kit = "0.14.3"
 # 实用工具与随机数
 rand = "0.9.2"
 nanoid = "0.4.0"
+lru = "0.16.3"
 
 # 日志与调试
 log = "0.4.29"

Cargo.toml

@@ -42,6 +42,8 @@ nanoid.workspace = true
 typetag.workspace = true
 dyn-clone.workspace = true
 once_cell.workspace = true
+enum_dispatch.workspace = true
+lru.workspace = true
 
 [target.'cfg(not(any(target_os = "android", target_arch = "wasm32")))'.dependencies]
 font-kit.workspace = true

crates/project_graph/Cargo.toml

@@ -7,7 +7,6 @@ pub mod fonts;
 pub mod settings;
 pub mod settings_window;
 pub mod stage;
-pub mod structs;
 pub mod themes;
 pub mod utils;
 

crates/project_graph/src/lib.rs

@@ -1,40 +1,27 @@
 mod camera;
+mod context;
+mod render_context;
+mod structs;
 
 use camera::Camera;
+use context::StageContext;
 use eframe::egui::{self};
-use egui::Pos2;
-use nanoid::nanoid;
-use rand::Rng;
+use structs::EntityTrait;
 
-use crate::structs::{StageObject, TextNode};
+use crate::stage::render_context::RenderContext;
 
 /// egui 和画布之间的桥梁
 /// 负责坐标系转换、事件处理等
 pub struct Stage {
     camera: Camera,
-    items: Vec<Box<dyn StageObject>>,
+    context: StageContext,
 }
 
 impl Stage {
     pub fn new() -> Self {
-        let mut rng = rand::rng();
-        let mut items = Vec::<Box<dyn StageObject>>::new();
-        for _ in 0..5 {
-            let pos = Pos2::new(
-                rng.random_range(-500.0..500.0),
-                rng.random_range(-500.0..500.0),
-            );
-
-            items.push(Box::new(TextNode {
-                id: nanoid!(),
-                position: pos,
-                content: "Hello, World!".to_string(),
-            }))
-        }
-
         Stage {
             camera: Camera::new(),
-            items,
+            context: StageContext::random(),
         }
     }
 
@@ -52,30 +39,16 @@ impl Stage {
             let screen_center = rect.center();
             let mut visible_count = 0;
 
-            for item in &self.items {
-                let screen_pos = self.camera.world_to_screen(
-                    item.as_any().downcast_ref::<TextNode>().unwrap().position,
-                    screen_center,
-                );
-
-                // 简单的视锥剔除 (Frustum Culling)
-                // 扩大一点范围以免边缘物体突然消失
-                // if !ui.clip_rect().expand(100.0).contains(screen_pos_egui) {
-                //     continue;
-                // }
-
+            for entity in self.context.entities().values() {
                 visible_count += 1;
-
-                ui.push_id(item.id(), |ui| {
-                    ui.with_visual_transform(
-                        egui::emath::TSTransform {
-                            translation: screen_pos.to_vec2(),
-                            scaling: self.camera.zoom(),
-                        },
-                        |ui| {
-                            item.render(ui);
-                        },
-                    );
+                let screen_pos = self
+                    .camera
+                    .world_to_screen(entity.position(), screen_center);
+
+                entity.render(&mut RenderContext {
+                    painter: painter.clone(),
+                    position: screen_pos,
+                    scale: self.camera.zoom(),
                 });
             }
 
@@ -90,22 +63,20 @@ impl Stage {
 
         let scroll_delta = ui.input(|i| i.smooth_scroll_delta);
         if scroll_delta.y != 0.0 {
-            let zoom_factor = (1.0 + scroll_delta.y * 0.01).clamp(0.9, 1.1);
-
             if let Some(mouse_pos) = ui.input(|i| i.pointer.hover_pos()) {
+                let zoom_factor = (1.0 + scroll_delta.y * 0.01).clamp(0.9, 1.1);
                 let old_zoom = self.camera.zoom();
-                let new_zoom = old_zoom * zoom_factor;
+                self.camera.zoom_by(zoom_factor);
+
                 let offset = mouse_pos - rect.center();
-                let delta = offset * (1.0 / old_zoom - 1.0 / new_zoom);
+                let delta = offset * (self.camera.zoom() / old_zoom - 1.0);
                 self.camera.pan_by(delta);
             }
-
-            self.camera.zoom_by(zoom_factor);
         }
 
         // 中键拖拽平移
         if response.dragged_by(egui::PointerButton::Middle) {
-            let drag_delta = ui.input(|i| i.pointer.delta()) / self.camera.zoom();
+            let drag_delta = ui.input(|i| i.pointer.delta());
             self.camera.pan_by(-drag_delta);
         }
     }

crates/project_graph/src/stage.rs

@@ -0,0 +1,41 @@
+use std::collections::HashMap;
+
+use egui::Pos2;
+use nanoid::nanoid;
+
+use crate::stage::structs::{Entity, TextNode};
+
+pub struct StageContext {
+    entities: HashMap<String, Entity>,
+}
+
+impl StageContext {
+    pub fn new() -> Self {
+        StageContext {
+            entities: HashMap::new(),
+        }
+    }
+    pub fn random() -> Self {
+        let mut entities: HashMap<String, Entity> = HashMap::new();
+        for i in 0..1000 {
+            let id = nanoid!();
+            entities.insert(
+                id.clone(),
+                TextNode {
+                    id,
+                    content: format!("节点 {}", i),
+                    position: Pos2::new(
+                        rand::random::<f32>() * 2000.0 - 1000.0,
+                        rand::random::<f32>() * 2000.0 - 1000.0,
+                    ),
+                }
+                .into(),
+            );
+        }
+        StageContext { entities }
+    }
+
+    pub fn entities(&self) -> &HashMap<String, Entity> {
+        &self.entities
+    }
+}

crates/project_graph/src/stage/context.rs

@@ -0,0 +1,42 @@
+use egui::{Painter, Pos2, Stroke, vec2};
+
+pub struct RenderContext {
+    pub painter: Painter,
+    pub position: Pos2,
+    pub scale: f32,
+}
+
+impl RenderContext {
+    pub fn local_to_screen(&self, local_pos: Pos2) -> Pos2 {
+        Pos2 {
+            x: self.position.x + local_pos.x * self.scale,
+            y: self.position.y + local_pos.y * self.scale,
+        }
+    }
+
+    pub fn rect(&self, local_rect: egui::Rect, color: egui::Color32) {
+        let screen_rect = egui::Rect {
+            min: self.local_to_screen(local_rect.min),
+            max: self.local_to_screen(local_rect.max),
+        };
+        self.painter.rect_stroke(
+            screen_rect,
+            8.0 * self.scale,
+            Stroke {
+                color,
+                width: self.scale,
+            },
+            egui::StrokeKind::Middle,
+        );
+    }
+
+    pub fn text(&self, position: Pos2, text: &str) {
+        self.painter.text(
+            self.local_to_screen(position) - vec2(0.0, 14.0 * 0.15) * self.scale,
+            egui::Align2::LEFT_TOP,
+            text,
+            egui::FontId::proportional(14.0 * self.scale),
+            egui::Color32::WHITE,
+        );
+    }
+}

crates/project_graph/src/stage/render_context.rs

@@ -0,0 +1,45 @@
+use egui::{Color32, Pos2, Rect, pos2};
+use enum_dispatch::enum_dispatch;
+
+use crate::{stage::render_context::RenderContext, utils::text::get_text_width};
+
+#[enum_dispatch]
+pub trait EntityTrait {
+    fn id(&self) -> &str;
+    fn position(&self) -> Pos2;
+    fn render(&self, rc: &mut RenderContext);
+}
+
+pub struct TextNode {
+    pub id: String,
+    pub position: Pos2,
+    pub content: String,
+}
+impl EntityTrait for TextNode {
+    fn id(&self) -> &str {
+        &self.id
+    }
+    fn position(&self) -> Pos2 {
+        self.position
+    }
+    fn render(&self, rc: &mut RenderContext) {
+        let padding = 8.0;
+
+        rc.rect(
+            Rect {
+                min: Pos2::ZERO,
+                max: Pos2 {
+                    x: get_text_width(&self.content, 14.0, &rc.painter) + padding * 2.0,
+                    y: 14.0 + padding * 2.0,
+                },
+            },
+            Color32::WHITE,
+        );
+        rc.text(pos2(padding, padding), &self.content);
+    }
+}
+
+#[enum_dispatch(EntityTrait)]
+pub enum Entity {
+    TextNode(TextNode),
+}