-use common::Point2D;
-use common::Radians;
+use geometry::{Angle, ToAngle, Point};
+use sdl2::GameControllerSubsystem;
use sdl2::HapticSubsystem;
-use sdl2::JoystickSubsystem;
+use sdl2::controller::{GameController, Axis as SDLAxis, Button as SDLButton};
use sdl2::event::Event;
use sdl2::haptic::Haptic;
-use sdl2::joystick::Joystick;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use time::{Duration, prelude::*};
+use {hashmap, point};
-#[derive(Debug, Default)]
+#[derive(Debug)]
pub struct Button {
- id: u8,
+ id: SDLButton,
pub time_pressed: Duration,
pub time_released: Duration,
pub is_pressed: bool,
}
impl Button {
- fn update(&mut self, device: &Joystick, dt: Duration) {
+ pub fn new(id: SDLButton) -> Self {
+ Button {
+ id,
+ time_pressed: Duration::zero(),
+ time_released: Duration::zero(),
+ is_pressed: false,
+ was_pressed: false,
+ toggle: false,
+ }
+ }
+
+ fn update(&mut self, device: &GameController, dt: Duration) {
self.was_pressed = self.is_pressed;
- self.is_pressed = match device.button(self.id as u32) {
- Ok(true) => {
+ self.is_pressed = match device.button(self.id) {
+ true => {
if !self.was_pressed {
self.time_pressed = 0.seconds();
self.toggle = !self.toggle;
self.time_pressed += dt;
true
}
- Ok(false) => {
+ false => {
if self.was_pressed {
self.time_released = 0.seconds();
}
self.time_released += dt;
false
}
- Err(_) => { panic!("invalid button {}", self.id) }
}
}
}
-#[derive(Debug, Default)]
+#[derive(Debug)]
pub struct Axis {
- id: u8,
+ id: SDLAxis,
pub val: f32,
}
impl Axis {
#[allow(dead_code)]
- fn update(&mut self, device: &Joystick, _dt: Duration) {
- self.val = match device.axis(self.id as u32) {
- Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid axis {}", self.id),
- }
+ fn update(&mut self, device: &GameController, _dt: Duration) {
+ self.val = device.axis(self.id) as f32 / 32768.0;
}
}
-#[derive(Debug, Default)]
+#[derive(Debug)]
pub struct Stick {
- idx: u8,
- idy: u8,
+ id: (SDLAxis, SDLAxis),
pub x: f32,
pub y: f32,
- pub a: Radians,
- pub len: f32,
+ pub a: Angle,
}
impl Stick {
- fn update(&mut self, device: &Joystick, _dt: Duration) {
- self.x = match device.axis(self.idx as u32) {
- Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid x axis {}", self.idx),
- };
- self.y = match device.axis(self.idy as u32) {
- Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid y axis {}", self.idy),
- };
- self.a = Radians(self.y.atan2(self.x) as f64);
- self.len = {
- let x = (self.x / self.y).abs().min(1.0);
- let y = (self.y / self.x).abs().min(1.0);
- (self.x.powi(2) + self.y.powi(2)).sqrt() / (x.powi(2) + y.powi(2)).sqrt()
+ pub fn new(idx: SDLAxis, idy: SDLAxis) -> Self {
+ Stick {
+ id: (idx, idy),
+ x: 0.0,
+ y: 0.0,
+ a: 0.radians(),
}
}
- #[inline(always)] #[allow(dead_code)] fn up(&self) -> bool { self.y > 0.99 }
- #[inline(always)] #[allow(dead_code)] fn down(&self) -> bool { self.y < -0.99 }
- #[inline(always)] #[allow(dead_code)] fn left(&self) -> bool { self.x < -0.99 }
- #[inline(always)] #[allow(dead_code)] fn right(&self) -> bool { self.x > 0.99 }
+ fn update(&mut self, device: &GameController, _dt: Duration) {
+ self.x = device.axis(self.id.0) as f32 / 32768.0;
+ self.y = device.axis(self.id.1) as f32 / 32768.0;
+ self.a = point!(self.x as f64, self.y as f64).to_angle();
+ }
- pub fn to_point(&self) -> Point2D<f64> {
- Point2D {
- x: self.x as f64,
- y: self.y as f64,
- }
+ #[inline(always)] #[allow(dead_code)] pub fn up(&self) -> bool { self.y < -0.99 }
+ #[inline(always)] #[allow(dead_code)] pub fn down(&self) -> bool { self.y > 0.99 }
+ #[inline(always)] #[allow(dead_code)] pub fn left(&self) -> bool { self.x < -0.99 }
+ #[inline(always)] #[allow(dead_code)] pub fn right(&self) -> bool { self.x > 0.99 }
+
+ pub fn to_axis_point(&self) -> Point<f64> {
+ point!(self.x as f64, self.y as f64)
}
- pub fn to_adjusted_point(&self) -> Point2D<f64> {
- Point2D::from(self.a) * self.len as f64
+ pub fn to_point(&self) -> Point<f64> {
+ let p = point!(self.x as f64, self.y as f64);
+ if p.length() > 1.0 {
+ p.normalized()
+ } else {
+ p
+ }
}
}
-impl From<&Stick> for Point2D<f64> {
+impl From<&Stick> for Point<f64> {
fn from(item: &Stick) -> Self {
Self {
x: item.x as f64,
}
}
-#[allow(dead_code)]
-struct Axes {
- left_x: u8,
- left_y: u8,
- right_x: u8,
- right_y: u8,
- trigger_left: u8,
- trigger_right: u8,
-}
-
-#[allow(dead_code)]
-struct Buttons {
- a: u8,
- b: u8,
- x: u8,
- y: u8,
- select: u8,
- start: u8,
- left_stick: u8,
- right_stick: u8,
- left_shoulder: u8,
- right_shoulder: u8,
- left_trigger: u8,
- right_trigger: u8,
- d_pad_up: u8,
- d_pad_down: u8,
- d_pad_left: u8,
- d_pad_right: u8,
-}
-
-struct Mapping {
- axis: Axes,
- btn: Buttons,
+#[derive(Eq, PartialEq, Hash)]
+enum ActionControls {
+ MovementX,
+ MovementY,
+ AimX,
+ AimY,
+ Jump,
+ Shoot,
+ Start,
}
+use self::ActionControls::*;
//#[derive(Debug)]
pub struct Controller {
- pub device: Joystick,
+ pub device: GameController,
haptic: Option<Rc<RefCell<Haptic>>>,
pub mov: Stick,
}
impl Controller {
- pub fn new(device: Joystick, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
+ pub fn new(device: GameController, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
+ let map = get_action_mapping();
let mut ctrl = Controller {
device,
haptic,
- mov: Default::default(),
- aim: Default::default(),
- jump: Default::default(),
- start: Default::default(),
- shoot: Default::default(),
- };
- let dualshock3 = Mapping {
- axis: Axes {
- left_x: 0,
- left_y: 1,
- right_x: 3,
- right_y: 4,
- trigger_left: 2,
- trigger_right: 5,
- },
- btn: Buttons {
- a: 0,
- b: 1,
- x: 3,
- y: 2,
- select: 8,
- start: 9,
- left_stick: 11,
- right_stick: 12,
- left_shoulder: 4,
- right_shoulder: 5,
- left_trigger: 6,
- right_trigger: 7,
- d_pad_up: 13,
- d_pad_down: 14,
- d_pad_left: 15,
- d_pad_right: 16,
- },
+ mov: Stick::new(*map.axes.get(&MovementX).unwrap(), *map.axes.get(&MovementY).unwrap()),
+ aim: Stick::new(*map.axes.get(&AimX).unwrap(), *map.axes.get(&AimY).unwrap()),
+ jump: Button::new(*map.buttons.get(&Jump).unwrap()),
+ start: Button::new(*map.buttons.get(&Start).unwrap()),
+ shoot: Button::new(*map.buttons.get(&Shoot).unwrap()),
};
- ctrl.set_mapping(&dualshock3);
+ ctrl.set_mapping(&map);
ctrl
}
- fn set_mapping(&mut self, map: &Mapping) {
- self.mov.idx = map.axis.left_x;
- self.mov.idy = map.axis.left_y;
- self.aim.idx = map.axis.right_x;
- self.aim.idy = map.axis.right_y;
- self.jump.id = map.btn.left_shoulder;
- self.shoot.id = map.btn.right_shoulder;
- self.start.id = map.btn.start;
+ fn set_mapping(&mut self, map: &ActionMapping) {
+ self.mov.id.0 = *map.axes.get(&MovementX).unwrap();
+ self.mov.id.1 = *map.axes.get(&MovementY).unwrap();
+ self.aim.id.0 = *map.axes.get(&AimX).unwrap();
+ self.aim.id.1 = *map.axes.get(&AimY).unwrap();
+ self.jump.id = *map.buttons.get(&Jump).unwrap();
+ self.shoot.id = *map.buttons.get(&Shoot).unwrap();
+ self.start.id = *map.buttons.get(&Start).unwrap();
}
pub fn update(&mut self, dt: Duration) {
}
}
+struct ActionMapping {
+ axes: HashMap<ActionControls, SDLAxis>,
+ buttons: HashMap<ActionControls, SDLButton>,
+}
+
+fn get_action_mapping() -> ActionMapping {
+ ActionMapping {
+ axes: hashmap!(
+ MovementX => SDLAxis::LeftX,
+ MovementY => SDLAxis::LeftY,
+ AimX => SDLAxis::RightX,
+ AimY => SDLAxis::RightY
+ ),
+ buttons: hashmap!(
+ Jump => SDLButton::A,
+ Shoot => SDLButton::RightShoulder,
+ Start => SDLButton::Start
+ )
+ }
+}
+
//#[derive(Debug)]
pub struct ControllerManager {
- pub joystick: JoystickSubsystem,
+ pub subsystem: GameControllerSubsystem,
haptic: Rc<HapticSubsystem>,
pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
}
impl ControllerManager {
- pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
- joystick.set_event_state(true);
+ pub fn new(subsystem: GameControllerSubsystem, haptic: HapticSubsystem) -> Self {
+ subsystem.set_event_state(true);
let mut c = ControllerManager {
- joystick,
+ subsystem,
haptic: Rc::new(haptic),
controllers: HashMap::new(),
};
}
fn init(&mut self) {
- for i in 0..self.joystick.num_joysticks().unwrap() {
+ for i in 0..self.subsystem.num_joysticks().unwrap() {
self.add_device(i);
}
}
pub fn handle_event(&mut self, event: &Event) {
match event {
- Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) }
- Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) }
- // Event::JoyButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
- // Event::JoyButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
- // Event::JoyAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
+ Event::ControllerDeviceAdded { which, .. } => { self.add_device(*which) }
+ Event::ControllerDeviceRemoved { which, .. } => { self.remove_device(*which) }
+ // Event::ControllerButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
+ // Event::ControllerButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
+ // Event::ControllerAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
_ => {}
}
}
fn add_device(&mut self, id: u32) {
println!("device added ({})!", id);
- let mut device = self.joystick.open(id).unwrap();
+ let mut device = self.subsystem.open(id).unwrap();
println!("opened {}", device.name());
/*
Dolda2000 GitWeb / kaka / rust-sdl-test.git / blobdiff