mitchellhansen/Trac3r-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

event work + mulling over sprite containers and event notification

Browse Source
This commit is contained in:
mitchellhansen
2020-07-31 23:39:25 -07:00
parent 55899f26ad
commit 8da810f23a
10 changed files with 149 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
src/main.rs
View File

@@ -36,7 +36,8 @@ use crate::util::timer::Timer;
use crate::util::vertex::{TextureVertex3D, VertexTypes};
use crate::vkprocessor::VkProcessor;
use std::path::Path;
use gilrs::{Gilrs, Button, Event as GilEvent};
use gilrs::{Gilrs, Button, Event as GilEvent, GamepadId, Gamepad};
use crate::util::tr_event::TrEvent;
pub mod util;
pub mod vkprocessor;
@@ -44,6 +45,36 @@ pub mod drawables;
pub mod canvas;
pub mod compute;
pub mod button_m {
use crate::drawables::rect::Rect;
use crate::drawables::sprite::Sprite;
use std::collections::HashSet;
use crate::canvas::canvas_frame::Drawable;
use crate::util::vertex::VertexTypes;
// Should I force these to be drawables
// or better, how do I force these to be drawables
enum GuiElements {
HANDLE(Rect),
GUIDE(Sprite)
}
pub struct Slider {
sprites: HashSet<GuiElements>,
}
impl Drawable for Slider {
fn get(&self) -> Vec<VertexTypes> {
self.sprites.into()
// self.sprites.iter().map(|v| {
//
// })
}
}
}
pub fn main() {
hprof::start_frame();
@@ -58,7 +89,7 @@ pub fn main() {
println!("Debug callback: {:?}", msg.description);
}).ok();
let mut events_loop = EventLoop::new();
let mut events_loop = EventLoop::<TrEvent>::with_user_event();
let mut surface = WindowBuilder::new()
.with_inner_size(LogicalSize::new(800, 800))
@@ -69,7 +100,6 @@ pub fn main() {
{
let g = hprof::enter("vulkan preload");
processor.create_swapchain(instance.clone(), surface.clone());
processor.preload_kernels();
processor.preload_shaders();
processor.preload_textures();
@@ -119,6 +149,8 @@ pub fn main() {
let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let rect = Rect::new((-0.5, -0.5), (0.5, 0.5), 1);
// how do i register a sprite to get events...
// explicit is much easier
//let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let text_sprite = Text::new((-0.1, -0.1), (10.0, 10.0), 1);
@@ -129,33 +161,47 @@ pub fn main() {
let l = hprof::enter("Loop");
// while let true = processor.is_open() {
//
// // Take care of our timing
// {
// elapsed_time = timer.elap_time();
// delta_time = elapsed_time - current_time;
// current_time = elapsed_time;
// if delta_time > 0.02 {
// delta_time = 0.02;
// }
// accumulator_time += delta_time;
// }
//
// while (accumulator_time - step_size) >= step_size {
// accumulator_time -= step_size;
// }
let mut gilrs = Gilrs::new().unwrap();
// Iterate over all connected gamepads
for (_id, gamepad) in gilrs.gamepads() {
println!("{} is {:?}", gamepad.name(), gamepad.power_info());
}
let event_loop_proxy = events_loop.create_proxy();
let mut active_gamepad = None;
std::thread::spawn(move || {
let mut gilrs = Gilrs::new().unwrap();
// Iterate over all connected gamepads
let mut gamepad : Option<Gamepad> = None;
for (_id, gamepad_) in gilrs.gamepads() {
if gamepad_.name() == "PS4" {
gamepad = Some(gamepad_);
}
println!("{} is {:?} {:?}", gamepad_.name(), gamepad_.power_info(), gamepad_.id());
}
let mut active_gamepad = None;
loop {
while let Some(GilEvent { id, event, time }) = gilrs.next_event() {
println!("{:?} New event from {}: {:?}", time, id, event);
active_gamepad = Some(id);
event_loop_proxy.send_event(TrEvent::GamepadEvent {
gil_event: GilEvent {id, event, time}
}).ok();
}
// // You can also use cached gamepad state
// if let Some(gamepad) = active_gamepad.map(|id| gilrs.gamepad(id)) {
// if gamepad.is_pressed(Button::South) {
// println!("Button South is pressed (XBox - A, PS - X)");
// }
// }
std::thread::sleep(std::time::Duration::from_millis(50));
}
});
// Events loop is borrowed from the surface
events_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Poll;
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
@@ -164,7 +210,27 @@ pub fn main() {
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => {
processor.swapchain_recreate_needed = true;
}
Event::UserEvent(TrEvent::KeyHeldEvent { }) => {
}
Event::MainEventsCleared => {
// while let true = processor.is_open() {
//
// // Take care of our timing
// {
// elapsed_time = timer.elap_time();
// delta_time = elapsed_time - current_time;
// current_time = elapsed_time;
// if delta_time > 0.02 {
// delta_time = 0.02;
// }
// accumulator_time += delta_time;
// }
//
// while (accumulator_time - step_size) >= step_size {
// accumulator_time -= step_size;
// }
let mut canvas_frame = CanvasFrame::default();
canvas_frame.draw(&funky_sprite);
canvas_frame.draw(&text_sprite);
@@ -181,18 +247,6 @@ pub fn main() {
compu_frame);
}
while let Some(GilEvent { id, event, time }) = gilrs.next_event() {
println!("{:?} New event from {}: {:?}", time, id, event);
active_gamepad = Some(id);
}
// You can also use cached gamepad state
if let Some(gamepad) = active_gamepad.map(|id| gilrs.gamepad(id)) {
if gamepad.is_pressed(Button::South) {
println!("Button South is pressed (XBox - A, PS - X)");
}
}
}
Event::DeviceEvent { event: DeviceEvent::Key(keyboard_input), .. } => {
match keyboard_input.virtual_keycode.unwrap() {
@@ -210,13 +264,29 @@ pub fn main() {
_ => ()
}
}
Event::UserEvent(TrEvent::GamepadEvent { gil_event }) => {
}
_ => ()
}
// bucket the events out, but not really
match event {
_ => {
funky_sprite.notify(&event);
}
Event::NewEvents(_) => {},
Event::WindowEvent { window_id, event } => {
},
Event::DeviceEvent { device_id, event } => {
},
Event::UserEvent(tr_event) => {
},
Event::Suspended => {},
Event::Resumed => {},
Event::MainEventsCleared => {},
Event::RedrawRequested(_) => {},
Event::RedrawEventsCleared => {},
Event::LoopDestroyed => {},
}
});