feat: bootstrap namespace-driven Tessera renderer

This commit is contained in:
2026-10-04 19:32:04 +08:00
commit 2f4c8f0fe2
14 changed files with 4262 additions and 0 deletions
+193
View File
@@ -0,0 +1,193 @@
use std::{
num::NonZeroU32,
sync::{Arc, RwLock},
};
use softbuffer::{Context, Surface};
use winit::{
application::ApplicationHandler,
dpi::{LogicalSize, PhysicalPosition},
event::{ElementState, MouseButton, WindowEvent},
event_loop::ActiveEventLoop,
keyboard::{Key, ModifiersState, NamedKey},
window::{Window, WindowAttributes, WindowId},
};
use crate::{
developer_tools::DeveloperToolsState,
document::NamespaceState,
geometry::Point,
scene::{self, SceneLayout},
software_renderer::SoftwareRenderer,
};
#[derive(Clone, Debug)]
pub enum AppEvent {
DocumentUpdated,
}
pub struct TesseraApp {
window: Option<Arc<Window>>,
context: Option<Context<Arc<Window>>>,
surface: Option<Surface<Arc<Window>, Arc<Window>>>,
namespace: Arc<RwLock<NamespaceState>>,
developer_tools: DeveloperToolsState,
layout: SceneLayout,
pointer: Point,
modifiers: ModifiersState,
}
impl TesseraApp {
pub fn new(namespace: Arc<RwLock<NamespaceState>>) -> Self {
Self {
window: None,
context: None,
surface: None,
namespace,
developer_tools: DeveloperToolsState::default(),
layout: SceneLayout::default(),
pointer: Point::default(),
modifiers: ModifiersState::default(),
}
}
fn request_redraw(&self) {
if let Some(window) = &self.window {
window.request_redraw();
}
}
fn toggle_developer_tools(&mut self) {
if let Ok(namespace) = self.namespace.read() {
self.developer_tools.toggle(&namespace.document);
}
self.request_redraw();
}
fn document_updated(&mut self) {
if let Ok(namespace) = self.namespace.read() {
self.developer_tools.document_updated(&namespace.document);
}
self.request_redraw();
}
fn handle_keyboard(&mut self, event: &winit::event::KeyEvent) {
if event.state != ElementState::Pressed || event.repeat {
return;
}
let is_f12 = matches!(event.logical_key, Key::Named(NamedKey::F12));
let is_i =
matches!(&event.logical_key, Key::Character(value) if value.eq_ignore_ascii_case("i"));
let mac_shortcut = self.modifiers.super_key() && self.modifiers.alt_key() && is_i;
let other_shortcut = self.modifiers.control_key() && self.modifiers.shift_key() && is_i;
if is_f12 || mac_shortcut || other_shortcut {
self.toggle_developer_tools();
}
}
fn handle_click(&mut self) {
let Some(node_id) = self.layout.developer_tools.node_at(self.pointer) else {
return;
};
self.developer_tools.selected_node_id = Some(node_id.to_owned());
self.request_redraw();
}
fn redraw(&mut self) {
let (Some(window), Some(surface)) = (self.window.as_ref(), self.surface.as_mut()) else {
return;
};
let size = window.inner_size();
let (Some(width), Some(height)) =
(NonZeroU32::new(size.width), NonZeroU32::new(size.height))
else {
return;
};
let Ok(namespace) = self.namespace.read() else {
return;
};
let scene = scene::build_scene(
size.width,
size.height,
window.scale_factor() as f32,
&namespace.document,
&self.developer_tools,
);
drop(namespace);
self.layout = scene.layout;
surface
.resize(width, height)
.expect("resize software surface");
let mut buffer = surface.buffer_mut().expect("acquire software buffer");
SoftwareRenderer::render(&scene.display_list, &mut buffer, size.width, size.height);
buffer.present().expect("present software-rendered frame");
}
}
impl ApplicationHandler<AppEvent> for TesseraApp {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.window.is_some() {
return;
}
let attributes = WindowAttributes::default()
.with_title("Tessera")
.with_inner_size(LogicalSize::new(1_280.0, 800.0))
.with_min_inner_size(LogicalSize::new(720.0, 480.0));
let window = Arc::new(
event_loop
.create_window(attributes)
.expect("create Tessera window"),
);
let context = Context::new(window.clone()).expect("create software-rendering context");
let surface =
Surface::new(&context, window.clone()).expect("create software-rendering surface");
self.window = Some(window.clone());
self.context = Some(context);
self.surface = Some(surface);
window.request_redraw();
}
fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: AppEvent) {
match event {
AppEvent::DocumentUpdated => self.document_updated(),
}
}
fn window_event(
&mut self,
event_loop: &ActiveEventLoop,
window_id: WindowId,
event: WindowEvent,
) {
let Some(window) = self.window.as_ref() else {
return;
};
if window.id() != window_id {
return;
}
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
window.request_redraw()
}
WindowEvent::CursorMoved {
position: PhysicalPosition { x, y },
..
} => self.pointer = Point::new(x as f32, y as f32),
WindowEvent::MouseInput {
state: ElementState::Released,
button: MouseButton::Left,
..
} => self.handle_click(),
WindowEvent::ModifiersChanged(modifiers) => self.modifiers = modifiers.state(),
WindowEvent::KeyboardInput { event, .. } => self.handle_keyboard(&event),
WindowEvent::RedrawRequested => self.redraw(),
_ => {}
}
}
}