shadowcat/openworm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switch to default iris app

Browse Source
This commit is contained in:
shadow cat
2025-12-04 14:31:34 -05:00
parent 1904560244
commit 02696b1f75
10 changed files with 61 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/bin/client/app.rs
View File

@@ -1,67 +0,0 @@
use std::sync::Arc;
use winit::{
application::ApplicationHandler,
event::WindowEvent,
event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
window::{Window, WindowId},
};
use crate::ClientEvent;
use super::Client;
#[derive(Clone)]
pub struct AppHandle {
pub proxy: EventLoopProxy<ClientEvent>,
pub window: Arc<Window>,
}
pub struct App {
client: Option<Client>,
proxy: EventLoopProxy<ClientEvent>,
}
impl App {
pub fn run() {
let event_loop = EventLoop::with_user_event().build().unwrap();
let proxy = event_loop.create_proxy();
event_loop
.run_app(&mut App {
client: Default::default(),
proxy,
})
.unwrap();
}
}
impl ApplicationHandler<ClientEvent> for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.client.is_none() {
let client = Client::new(event_loop, self.proxy.clone());
self.client = Some(client);
}
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
let client = self.client.as_mut().unwrap();
client.window_event(event, event_loop);
}
fn user_event(&mut self, event_loop: &ActiveEventLoop, event: ClientEvent) {
let client = self.client.as_mut().unwrap();
client.event(event, event_loop);
}
fn exiting(&mut self, _: &ActiveEventLoop) {
let client = self.client.as_mut().unwrap();
client.exit();
}
}
impl AppHandle {
pub fn send(&self, event: ClientEvent) {
self.proxy.send_event(event).unwrap_or_else(|_| panic!());
self.window.request_redraw();
}
}

83
src/bin/client/input.rs
View File

@@ -1,83 +0,0 @@
use iris::{
core::{CursorState, Modifiers},
layout::Vec2,
};
use winit::{
event::{MouseButton, MouseScrollDelta, WindowEvent},
keyboard::{Key, NamedKey},
};
use super::Client;
#[derive(Default)]
pub struct Input {
cursor: CursorState,
pub modifiers: Modifiers,
}
impl Input {
pub fn event(&mut self, event: &WindowEvent) -> bool {
match event {
WindowEvent::CursorMoved { position, .. } => {
self.cursor.pos = Vec2::new(position.x as f32, position.y as f32);
self.cursor.exists = true;
}
WindowEvent::MouseInput { state, button, .. } => {
let buttons = &mut self.cursor.buttons;
let pressed = state.is_pressed();
match button {
MouseButton::Left => buttons.left.update(pressed),
MouseButton::Right => buttons.right.update(pressed),
MouseButton::Middle => buttons.middle.update(pressed),
_ => (),
}
}
WindowEvent::MouseWheel { delta, .. } => {
let mut delta = match *delta {
MouseScrollDelta::LineDelta(x, y) => Vec2::new(x, y),
MouseScrollDelta::PixelDelta(pos) => Vec2::new(pos.x as f32, pos.y as f32),
};
if delta.x == 0.0 && self.modifiers.shift {
delta.x = delta.y;
delta.y = 0.0;
}
self.cursor.scroll_delta = delta;
}
WindowEvent::CursorLeft { .. } => {
self.cursor.exists = false;
self.modifiers.clear();
}
WindowEvent::KeyboardInput { event, .. } => {
if let Key::Named(named) = event.logical_key {
let pressed = event.state.is_pressed();
match named {
NamedKey::Control => {
self.modifiers.control = pressed;
}
NamedKey::Shift => {
self.modifiers.shift = pressed;
}
_ => (),
}
}
}
_ => return false,
}
true
}
pub fn end_frame(&mut self) {
self.cursor.end_frame();
}
}
impl Client {
pub fn window_size(&self) -> Vec2 {
let size = self.renderer.window().inner_size();
(size.width, size.height).into()
}
pub fn cursor_state(&self) -> &CursorState {
&self.input.cursor
}
}

172
src/bin/client/main.rs
View File

@@ -1,56 +1,37 @@
#![windows_subsystem = "windows"]
use crate::{
app::App,
net::{NetHandle, NetSender},
rsc::{CLIENT_DATA, ClientData},
state::{ClientState, LoggedIn, Login},
ui::*,
};
pub use app::AppHandle;
use arboard::Clipboard;
use input::Input;
use iris::prelude::*;
use iris::{prelude::*, winit::*};
use openworm::{
net::{ClientMsg, ServerMsg, install_crypto_provider},
rsc::DataDir,
};
use render::Renderer;
use std::{sync::Arc, time::Instant};
use winit::{
event::{ElementState, Ime, MouseButton, WindowEvent},
event_loop::{ActiveEventLoop, EventLoopProxy},
window::Window,
};
use winit::event::{ElementState, MouseButton, WindowEvent};
mod app;
mod debug;
mod input;
mod net;
mod render;
mod rsc;
mod state;
mod ui;
fn main() {
install_crypto_provider();
App::run();
UiApp::<Client>::run();
}
pub struct Client {
renderer: Renderer,
input: Input,
ui: Ui,
focus: Option<WidgetId<TextEdit>>,
clipboard: Clipboard,
dir: DataDir,
data: ClientData,
handle: AppHandle,
state: ClientState,
ime: usize,
last_click: Instant,
main_ui: WidgetId<WidgetPtr>,
notif: WidgetId<WidgetPtr>,
ui: DefaultUi,
proxy: Proxy<ClientEvent>,
}
pub enum ClientEvent {
@@ -59,18 +40,15 @@ pub enum ClientEvent {
Err(String),
}
impl Client {
pub fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<ClientEvent>) -> Self {
let window = Arc::new(
event_loop
.create_window(Window::default_attributes().with_title("OPENWORM"))
.unwrap(),
);
let renderer = Renderer::new(window.clone());
let dir = DataDir::default();
let handle = AppHandle { proxy, window };
impl DefaultUiState for Client {
type Event = ClientEvent;
let mut ui = Ui::new();
fn ui(&mut self) -> &mut DefaultUi {
&mut self.ui
}
fn new(mut ui: DefaultUi, proxy: Proxy<Self::Event>) -> Self {
let dir = DataDir::default();
let notif = WidgetPtr::default().add(&mut ui);
let main_ui = WidgetPtr::default().add(&mut ui);
(
@@ -81,31 +59,25 @@ impl Client {
.set_root(&mut ui);
let mut s = Self {
handle,
renderer,
input: Input::default(),
ui,
data: dir.load(CLIENT_DATA),
state: Default::default(),
dir,
focus: None,
clipboard: Clipboard::new().unwrap(),
ime: 0,
last_click: Instant::now(),
main_ui: main_ui.clone(),
notif,
ui,
proxy,
};
connect_screen(&mut s).set_ptr(&main_ui, &mut s.ui);
connect_screen(&mut s).set_ptr(&s.main_ui, &mut s.ui);
s
}
pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
fn event(&mut self, event: ClientEvent) {
match event {
ClientEvent::Connect { send } => {
let ClientState::Connect(state) = self.state.take() else {
let ClientState::Connect(connect) = self.state.take() else {
panic!("invalid state");
};
let th = state.handle.unwrap();
let th = connect.handle.unwrap();
self.state = ClientState::Login(Login {
handle: NetHandle {
send: send.clone(),
@@ -158,105 +130,19 @@ impl Client {
}
}
pub fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
let input_changed = self.input.event(&event);
let cursor_state = self.cursor_state().clone();
let old = self.focus.clone();
if cursor_state.buttons.left.is_start() {
self.focus = None;
}
if input_changed {
let window_size = self.window_size();
self.run_sensors(&cursor_state, window_size);
self.ui.run_sensors(&cursor_state, window_size);
}
if old != self.focus
&& let Some(old) = old
{
self.ui.text(&old).deselect();
}
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::RedrawRequested => {
self.ui.update();
self.renderer.update(&mut self.ui);
self.renderer.draw();
}
WindowEvent::Resized(size) => {
self.ui.resize((size.width, size.height));
self.renderer.resize(&size)
}
WindowEvent::KeyboardInput { event, .. } => {
if let Some(sel) = &self.focus
&& event.state.is_pressed()
{
let sel = &sel.clone();
let mut text = self.ui.text(sel);
match text.apply_event(&event, &self.input.modifiers) {
TextInputResult::Unfocus => {
self.focus = None;
self.handle.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
self.run_event(sel, Submit, ());
}
TextInputResult::Paste => {
if let Ok(t) = self.clipboard.get_text() {
text.insert(&t);
}
self.run_event(sel, Edited, ());
}
TextInputResult::Copy(text) => {
if let Err(err) = self.clipboard.set_text(text) {
eprintln!("failed to copy text to clipboard: {err}")
}
}
TextInputResult::Used => {
self.run_event(sel, Edited, ());
}
TextInputResult::Unused => {}
}
}
}
WindowEvent::MouseInput {
state: ElementState::Pressed,
button: MouseButton::Middle,
..
} => {
debug::debug(self);
}
WindowEvent::Ime(ime) => {
if let Some(sel) = &self.focus {
let mut text = self.ui.text(sel);
match ime {
Ime::Enabled | Ime::Disabled => (),
Ime::Preedit(content, _pos) => {
// TODO: highlight once that's real
text.replace(self.ime, &content);
self.ime = content.chars().count();
}
Ime::Commit(content) => {
text.insert(&content);
}
}
}
}
_ => (),
}
if self.ui.needs_redraw() {
self.renderer.window().request_redraw();
}
self.input.end_frame();
}
pub fn exit(&mut self) {
fn exit(&mut self) {
self.state.exit();
self.dir.save(CLIENT_DATA, &self.data);
}
}
impl UiCtx for Client {
fn ui(&mut self) -> &mut Ui {
&mut self.ui
fn window_event(&mut self, event: WindowEvent) {
if let WindowEvent::MouseInput {
state: ElementState::Pressed,
button: MouseButton::Middle,
..
} = event
{
debug::debug(self);
}
}
}

16
src/bin/client/net.rs
View File

@@ -1,4 +1,4 @@
use crate::{AppHandle, ClientEvent};
use crate::ClientEvent;
use openworm::net::{
ClientMsg, RecvHandler, SERVER_NAME, ServerMsg, SkipServerVerification, recv_uni, send_uni,
};
@@ -13,6 +13,7 @@ use std::{
time::Duration,
};
use tokio::sync::mpsc::UnboundedSender;
use winit::{event_loop::EventLoopProxy, window::Window};
pub const CLIENT_SOCKET: SocketAddr =
SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, 0, 0, 0));
@@ -26,6 +27,19 @@ pub struct NetHandle {
pub thread: JoinHandle<()>,
}
#[derive(Clone)]
pub struct AppHandle {
pub proxy: EventLoopProxy<ClientEvent>,
pub window: Arc<Window>,
}
impl AppHandle {
pub fn send(&self, event: ClientEvent) {
self.proxy.send_event(event).unwrap_or_else(|_| panic!());
self.window.request_redraw();
}
}
pub fn connect(handle: AppHandle, info: ConnectInfo) -> JoinHandle<()> {
std::thread::spawn(move || {
if let Err(msg) = connect_the(handle.clone(), info) {

153
src/bin/client/render/mod.rs
View File

@@ -1,153 +0,0 @@
use iris::{
layout::Ui,
render::{UiLimits, UiRenderer},
};
use pollster::FutureExt;
use std::sync::Arc;
use wgpu::{util::StagingBelt, *};
use winit::{dpi::PhysicalSize, window::Window};
pub const CLEAR_COLOR: Color = Color::BLACK;
pub struct Renderer {
window: Arc<Window>,
surface: Surface<'static>,
device: Device,
queue: Queue,
config: SurfaceConfiguration,
encoder: CommandEncoder,
staging_belt: StagingBelt,
pub ui: UiRenderer,
}
impl Renderer {
pub fn update(&mut self, updates: &mut Ui) {
self.ui.update(&self.device, &self.queue, updates);
}
pub fn draw(&mut self) {
let output = self.surface.get_current_texture().unwrap();
let view = output
.texture
.create_view(&TextureViewDescriptor::default());
let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device));
{
let render_pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
color_attachments: &[Some(RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: Operations {
load: LoadOp::Clear(CLEAR_COLOR),
store: StoreOp::Store,
},
depth_slice: None,
})],
..Default::default()
});
self.ui.draw(render_pass);
}
self.queue.submit(std::iter::once(encoder.finish()));
self.staging_belt.finish();
output.present();
self.staging_belt.recall();
}
pub fn resize(&mut self, size: &PhysicalSize<u32>) {
self.config.width = size.width;
self.config.height = size.height;
self.surface.configure(&self.device, &self.config);
self.ui.resize(size, &self.queue);
}
fn create_encoder(device: &Device) -> CommandEncoder {
device.create_command_encoder(&CommandEncoderDescriptor {
label: Some("Render Encoder"),
})
}
pub fn new(window: Arc<Window>) -> Self {
let size = window.inner_size();
let instance = Instance::new(&InstanceDescriptor {
backends: Backends::PRIMARY,
flags: InstanceFlags::empty(),
..Default::default()
});
let surface = instance
.create_surface(window.clone())
.expect("Could not create window surface!");
let adapter = instance
.request_adapter(&RequestAdapterOptions {
power_preference: PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
})
.block_on()
.expect("Could not get adapter!");
let ui_limits = UiLimits::default();
let (device, queue) = adapter
.request_device(&DeviceDescriptor {
required_features: Features::TEXTURE_BINDING_ARRAY
| Features::PARTIALLY_BOUND_BINDING_ARRAY
| Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
required_limits: Limits {
max_binding_array_elements_per_shader_stage: ui_limits
.max_binding_array_elements_per_shader_stage(),
max_binding_array_sampler_elements_per_shader_stage: ui_limits
.max_binding_array_sampler_elements_per_shader_stage(),
max_buffer_size: 1 << 30,
..Default::default()
},
..Default::default()
})
.block_on()
.expect("Could not get device!");
let surface_caps = surface.get_capabilities(&adapter);
let surface_format = surface_caps
.formats
.iter()
.copied()
.find(|f| f.is_srgb())
.unwrap_or(surface_caps.formats[0]);
let config = SurfaceConfiguration {
usage: TextureUsages::RENDER_ATTACHMENT,
format: surface_format,
width: size.width,
height: size.height,
present_mode: PresentMode::AutoVsync,
alpha_mode: surface_caps.alpha_modes[0],
desired_maximum_frame_latency: 2,
view_formats: vec![],
};
surface.configure(&device, &config);
let staging_belt = StagingBelt::new(4096 * 4);
let encoder = Self::create_encoder(&device);
let shape_pipeline = UiRenderer::new(&device, &queue, &config, ui_limits);
Self {
surface,
device,
queue,
config,
encoder,
staging_belt,
ui: shape_pipeline,
window,
}
}
pub fn window(&self) -> &Window {
self.window.as_ref()
}
}

10
src/bin/client/ui/login.rs
View File

@@ -1,6 +1,7 @@
use iris::winit::{attr::Selector, event::Edited};
use openworm::net::ClientMsg;
use crate::state::ClientState;
use crate::{net::AppHandle, state::ClientState};
use super::*;
@@ -37,11 +38,14 @@ pub fn submit_button(text: &str, on_submit: impl Fn(&mut Client) + 'static) -> i
pub fn connect_screen(client: &mut Client) -> WidgetId {
let Client {
data, ui, handle, ..
data, ui, proxy, ..
} = client;
let ip = field_widget(&data.ip, "ip", ui);
let ip_ = ip.clone();
let handle = handle.clone();
let handle = AppHandle {
proxy: proxy.clone(),
window: ui.window.clone(),
};
let submit = submit_button("connect", move |client| {
let ClientState::Connect(state) = &mut client.state else {
return;

12
src/bin/client/ui/main.rs
View File

@@ -1,7 +1,13 @@
use super::*;
use crate::state::{ClientState, LoggedIn};
use iris::layout::len_fns::*;
use openworm::net::{ClientMsg, NetClientMsg, NetServerMsg};
use iris::{
layout::len_fns::*,
winit::{
attr::{Selectable, Selector},
event::Submit,
},
};
use openworm::net::{ClientMsg, NetClientMsg};
pub const SIZE: u32 = 20;
@@ -74,7 +80,7 @@ pub fn msg_panel(ui: &mut Ui, state: &mut LoggedIn) -> impl WidgetRet + use<> {
content: content.clone(),
};
state.network.send(ClientMsg::SendMsg(msg.clone()));
let msg = msg_widget(&client.data.username, &content).add(&mut client.ui);
let msg = msg_widget(&state.username, &content).add(&mut client.ui);
client.ui[&msg_area].children.push(msg.any());
})
.pad(15)

59
src/bin/client/ui/misc.rs
View File

@@ -1,5 +1,3 @@
use std::time::{Duration, Instant};
use super::*;
pub fn werror(ui: &mut Ui, msg: &str) -> WidgetId {
@@ -11,63 +9,6 @@ pub fn werror(ui: &mut Ui, msg: &str) -> WidgetId {
.any()
}
pub struct Selector;
impl<W: 'static> WidgetAttr<W> for Selector {
type Input = WidgetId<TextEdit>;
fn run(ui: &mut Ui, container: &WidgetId<W>, id: Self::Input) {
let container = container.clone();
ui.register_event(
&container.clone(),
CursorSense::click_or_drag(),
move |client: &mut Client, mut data| {
let region = client.ui.window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = client.ui.window_region(&container).unwrap().top_left;
data.cursor += container_pos - id_pos;
data.size = region.size();
select(id.clone(), client, data);
},
);
}
}
pub struct Selectable;
impl WidgetAttr<TextEdit> for Selectable {
type Input = ();
fn run(ui: &mut Ui, id: &WidgetId<TextEdit>, _: Self::Input) {
let id = id.clone();
ui.register_event(
&id.clone(),
CursorSense::click_or_drag(),
move |client: &mut Client, data| {
select(id.clone(), client, data);
},
);
}
}
fn select(id: WidgetId<TextEdit>, client: &mut Client, data: CursorData) {
let now = Instant::now();
let recent = (now - client.last_click) < Duration::from_millis(300);
client.last_click = now;
client
.ui
.text(&id)
.select(data.cursor, data.size, data.sense.is_dragging(), recent);
if let Some(region) = client.ui.window_region(&id) {
client.handle.window.set_ime_allowed(true);
client.handle.window.set_ime_cursor_area(
LogicalPosition::<f32>::from(region.top_left.tuple()),
LogicalSize::<f32>::from(region.size().tuple()),
);
}
client.focus = Some(id);
}
pub fn hint(msg: impl Into<String>) -> TextBuilder {
wtext(msg).size(20).color(Color::GRAY)
}

15
src/bin/client/ui/mod.rs
View File

@@ -3,7 +3,6 @@ use crate::{
net::{ConnectInfo, connect},
};
use iris::prelude::*;
use winit::dpi::{LogicalPosition, LogicalSize};
mod login;
mod main;
@@ -11,17 +10,3 @@ mod misc;
pub use login::*;
pub use main::*;
pub use misc::*;
#[derive(Eq, PartialEq, Hash, Clone)]
pub struct Submit;
#[derive(Eq, PartialEq, Hash, Clone)]
pub struct Edited;
impl DefaultEvent for Submit {
type Data = ();
}
impl DefaultEvent for Edited {
type Data = ();
}