Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Moving to a single crossbeam channel as a detail of Window, using strings instead of ClientEvent, and formatting

Browse Source
This commit is contained in:
Joey Maher 2020-06-05 15:53:15 -05:00
parent 8d90952074
commit 09541af551
4 changed files with 38 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
voxygen/src/menu/char_selection/mod.rs
View File

@ -7,11 +7,11 @@ use crate::{
window::Event as WinEvent,
Direction, GlobalState, PlayState, PlayStateResult,
};
use client::{self, Client, Event as ClientEvent};
use client::{self, Client};
use common::{assets, clock::Clock, comp, msg::ClientState, state::DeltaTime};
use log::error;
use specs::WorldExt;
use std::{cell::RefCell, rc::Rc, time::Duration, sync::mpsc};
use std::{cell::RefCell, rc::Rc, time::Duration};
use ui::CharSelectionUi;
pub struct CharSelectionState {
@ -42,12 +42,10 @@ impl PlayState for CharSelectionState {
// Load the player's character list
self.client.borrow_mut().load_character_list();
let (message_sender, _message_receiver): (mpsc::Sender<ClientEvent>, mpsc::Receiver<ClientEvent>) = mpsc::channel();
let mut current_client_state = self.client.borrow().get_client_state();
while let ClientState::Pending | ClientState::Registered = current_client_state {
// Handle window events
for event in global_state.window.fetch_events(&mut global_state.settings, &message_sender) {
for event in global_state.window.fetch_events(&mut global_state.settings) {
if self.char_selection_ui.handle_event(event.clone()) {
continue;
}

6
voxygen/src/menu/main/mod.rs
View File

@ -11,8 +11,6 @@ use log::{error, warn};
#[cfg(feature = "singleplayer")]
use std::time::Duration;
use ui::{Event as MainMenuEvent, MainMenuUi};
use std::sync::mpsc;
use client::{self, Event as ClientEvent};
pub struct MainMenuState {
main_menu_ui: MainMenuUi,
@ -49,11 +47,9 @@ impl PlayState for MainMenuState {
&crate::i18n::i18n_asset_key(&global_state.settings.language.selected_language),
);
let (message_sender, _message_receiver): (mpsc::Sender<ClientEvent>, mpsc::Receiver<ClientEvent>) = mpsc::channel();
loop {
// Handle window events.
for event in global_state.window.fetch_events(&mut global_state.settings, &message_sender) {
for event in global_state.window.fetch_events(&mut global_state.settings) {
match event {
Event::Close => return PlayStateResult::Shutdown,
// Pass events to ui.

18
voxygen/src/session.rs
View File

@ -9,7 +9,7 @@ use crate::{
window::{AnalogGameInput, Event, GameInput},
Direction, Error, GlobalState, PlayState, PlayStateResult,
};
use client::{self, Client, Event::Chat, Event as ClientEvent};
use client::{self, Client, Event::Chat};
use common::{
assets::{load_watched, watch},
clock::Clock,
@ -23,7 +23,7 @@ use common::{
};
use log::error;
use specs::{Join, WorldExt};
use std::{cell::RefCell, rc::Rc, time::Duration, sync::mpsc};
use std::{cell::RefCell, rc::Rc, time::Duration};
use vek::*;
/// The action to perform after a tick
@ -143,8 +143,6 @@ impl PlayState for SessionState {
let mut ori = self.scene.camera().get_orientation();
let mut free_look = false;
let (message_sender, message_receiver): (mpsc::Sender<ClientEvent>, mpsc::Receiver<ClientEvent>) = mpsc::channel();
// Game loop
let mut current_client_state = self.client.borrow().get_client_state();
while let ClientState::Pending | ClientState::Character = current_client_state {
@ -226,14 +224,8 @@ impl PlayState for SessionState {
.unwrap_or(false)
}));
// Receive any ClientEvents sent through the message channel
match message_receiver.try_recv() {
Ok(message_event) => self.hud.new_message(message_event),
Err(_x) => {},
};
// Handle window events.
for event in global_state.window.fetch_events(&mut global_state.settings, &message_sender) {
for event in global_state.window.fetch_events(&mut global_state.settings) {
// Pass all events to the ui first.
if self.hud.handle_event(event.clone(), global_state) {
continue;
@ -461,6 +453,10 @@ impl PlayState for SessionState {
self.scene.handle_input_event(Event::AnalogGameInput(other));
},
},
Event::ScreenshotSaved(screenshot_message) => self.hud.new_message(Chat {
chat_type: ChatType::Meta,
message: screenshot_message,
}),
// Pass all other events to the scene
event => {

53
voxygen/src/window.rs
View File

@ -7,14 +7,10 @@ use crate::{
use gilrs::{EventType, Gilrs};
use hashbrown::HashMap;
use crossbeam::channel;
use log::{error, warn};
use serde_derive::{Deserialize, Serialize};
use std::fmt;
use std::sync::mpsc::Sender;
use client::{self, Event as ClientEvent};
use common::{
ChatType,
};
use vek::*;
/// Represents a key that the game recognises after input mapping.
@ -191,6 +187,8 @@ pub enum Event {
AnalogMenuInput(AnalogMenuInput),
/// Update of the analog inputs recognized by the game
AnalogGameInput(AnalogGameInput),
/// We tried to save a screenshot
ScreenshotSaved(String),
}
pub type MouseButton = winit::MouseButton;
@ -396,6 +394,8 @@ pub struct Window {
controller_settings: ControllerSettings,
cursor_position: winit::dpi::LogicalPosition,
mouse_emulation_vec: Vec2<f32>,
message_channel_sender: channel::Sender<String>,
message_channel_receiver: channel::Receiver<String>,
}
impl Window {
@ -450,6 +450,11 @@ impl Window {
let controller_settings = ControllerSettings::from(&settings.controller);
let (message_sender, message_receiver): (
channel::Sender<String>,
channel::Receiver<String>,
) = channel::unbounded::<String>();
let mut this = Self {
events_loop,
renderer: Renderer::new(
@ -477,6 +482,8 @@ impl Window {
controller_settings,
cursor_position: winit::dpi::LogicalPosition::new(0.0, 0.0),
mouse_emulation_vec: Vec2::zero(),
message_channel_sender: message_sender,
message_channel_receiver: message_receiver,
};
this.fullscreen(settings.graphics.fullscreen);
@ -488,7 +495,7 @@ impl Window {
pub fn renderer_mut(&mut self) -> &mut Renderer { &mut self.renderer }
pub fn fetch_events(&mut self, settings: &mut Settings, message_sender: &Sender<ClientEvent>) -> Vec<Event> {
pub fn fetch_events(&mut self, settings: &mut Settings) -> Vec<Event> {
let mut events = vec![];
events.append(&mut self.supplement_events);
// Refresh ui size (used when changing playstates)
@ -497,6 +504,12 @@ impl Window {
self.needs_refresh_resize = false;
}
// Receive any messages sent through the message channel
match self.message_channel_receiver.try_recv() {
Ok(message_string) => events.push(Event::ScreenshotSaved(message_string)),
Err(_x) => {},
}
// Copy data that is needed by the events closure to avoid lifetime errors.
// TODO: Remove this if/when the compiler permits it.
let cursor_grabbed = self.cursor_grabbed;
@ -656,7 +669,7 @@ impl Window {
}
if take_screenshot {
self.take_screenshot(&settings, &message_sender);
self.take_screenshot(&settings);
}
if toggle_fullscreen {
@ -929,11 +942,11 @@ impl Window {
pub fn send_supplement_event(&mut self, event: Event) { self.supplement_events.push(event) }
pub fn take_screenshot(&mut self, settings: &Settings, message_sender: &Sender<ClientEvent>) {
pub fn take_screenshot(&mut self, settings: &Settings) {
match self.renderer.create_screenshot() {
Ok(img) => {
let mut path = settings.screenshots_path.clone();
let sender = message_sender.clone();
let sender = self.message_channel_sender.clone();
std::thread::spawn(move || {
use std::time::SystemTime;
@ -941,10 +954,8 @@ impl Window {
if !path.exists() {
if let Err(err) = std::fs::create_dir_all(&path) {
warn!("Couldn't create folder for screenshot: {:?}", err);
let _result = sender.send(ClientEvent::Chat {
chat_type: ChatType::Meta,
message: String::from("Couldn't create folder for screenshot"),
});
let _result =
sender.send(String::from("Couldn't create folder for screenshot"));
}
}
path.push(format!(
@ -956,20 +967,10 @@ impl Window {
));
if let Err(err) = img.save(&path) {
warn!("Couldn't save screenshot: {:?}", err);
let _result = sender.send(ClientEvent::Chat {
chat_type: ChatType::Meta,
message: String::from("Couldn't save screenshot"),
});
let _result = sender.send(String::from("Couldn't save screenshot"));
} else {
match path.to_str() {
Some(x) => {
let _result = sender.send(ClientEvent::Chat {
chat_type: ChatType::Meta,
message: format!("Screenshot saved to {}", x),
});
},
None => {}
}
let _result =
sender.send(format!("Screenshot saved to {}", path.to_string_lossy()));
}
});
},