mirror of
https://github.com/moonlight-stream/moonlight-embedded.git
synced 2026-04-10 01:46:16 +00:00
rewrote gamepad stuff to not use JInput
This commit is contained in:
Diego Waxemberg
25
src/com/limelight/input/Device.java
Normal file
25
src/com/limelight/input/Device.java
Normal file
@@ -0,0 +1,25 @@
|
||||
package com.limelight.input;
|
||||
|
||||
public class Device {
|
||||
private int id;
|
||||
private int numButtons;
|
||||
private int numAxes;
|
||||
|
||||
public Device(int deviceID, int numButtons, int numAxes) {
|
||||
this.id = deviceID;
|
||||
this.numButtons = numButtons;
|
||||
this.numAxes = numAxes;
|
||||
}
|
||||
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public int getNumButtons() {
|
||||
return numButtons;
|
||||
}
|
||||
|
||||
public int getNumAxes() {
|
||||
return numAxes;
|
||||
}
|
||||
}
|
||||
6
src/com/limelight/input/DeviceListener.java
Normal file
6
src/com/limelight/input/DeviceListener.java
Normal file
@@ -0,0 +1,6 @@
|
||||
package com.limelight.input;
|
||||
|
||||
public interface DeviceListener {
|
||||
public void handleButton(Device device, int buttonId, boolean pressed);
|
||||
public void handleAxis(Device device, int axisId, float newValue, float lastValue);
|
||||
}
|
||||
@@ -1,23 +1,19 @@
|
||||
package com.limelight.input.gamepad;
|
||||
|
||||
import com.limelight.input.Device;
|
||||
import com.limelight.input.DeviceListener;
|
||||
import com.limelight.input.gamepad.GamepadMapping.Mapping;
|
||||
import com.limelight.input.gamepad.SourceComponent.Type;
|
||||
import com.limelight.nvstream.NvConnection;
|
||||
import com.limelight.nvstream.input.ControllerPacket;
|
||||
|
||||
import net.java.games.input.Component;
|
||||
import net.java.games.input.Component.Identifier;
|
||||
import net.java.games.input.Controller;
|
||||
import net.java.games.input.Event;
|
||||
import net.java.games.input.EventQueue;
|
||||
import com.limelight.settings.GamepadSettingsManager;
|
||||
|
||||
/**
|
||||
* Represents a gamepad connected to the system
|
||||
* @author Diego Waxemberg
|
||||
*/
|
||||
public class Gamepad {
|
||||
private Controller pad;
|
||||
private GamepadMapping config;
|
||||
|
||||
public class Gamepad implements DeviceListener {
|
||||
|
||||
private short inputMap = 0x0000;
|
||||
private byte leftTrigger = 0x00;
|
||||
private byte rightTrigger = 0x00;
|
||||
@@ -26,231 +22,78 @@ public class Gamepad {
|
||||
private short leftStickX = 0x0000;
|
||||
private short leftStickY = 0x0000;
|
||||
|
||||
/**
|
||||
* Constructs a new gamepad from the specified controller that has the given mappings
|
||||
* @param pad the controller to be used as a gamepad
|
||||
* @param settings the mappings for the gamepad
|
||||
*/
|
||||
public Gamepad(Controller pad, GamepadMapping settings) {
|
||||
this.config = settings;
|
||||
this.pad = pad;
|
||||
|
||||
for (Component comp : pad.getComponents()) {
|
||||
initValue(comp);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Initializes the value of the given component to its current state
|
||||
*/
|
||||
private void initValue(Component comp) {
|
||||
handleComponent(comp, comp.getPollData());
|
||||
}
|
||||
|
||||
/**
|
||||
* Polls the gamepad for component values.
|
||||
* @return true if the gamepad was polled successfully, false otherwise
|
||||
*/
|
||||
public boolean poll() {
|
||||
return pad.poll();
|
||||
}
|
||||
|
||||
/*
|
||||
* Sends a controller packet to the specified connection containing the current gamepad values
|
||||
*/
|
||||
private void sendControllerPacket(NvConnection conn) {
|
||||
if (conn != null) {
|
||||
conn.sendControllerInput(inputMap, leftTrigger, rightTrigger,
|
||||
leftStickX, leftStickY, rightStickX, rightStickY);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the event queue for this gamepad
|
||||
* @return this gamepad's event queue
|
||||
*/
|
||||
public EventQueue getEvents() {
|
||||
return pad.getEventQueue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the events in this gamepad's event queue and sends them
|
||||
* to the specified connection
|
||||
* @param conn the connection to the host that will receive the events
|
||||
*/
|
||||
public void handleEvents(NvConnection conn) {
|
||||
EventQueue queue = pad.getEventQueue();
|
||||
Event event = new Event();
|
||||
|
||||
while(queue.getNextEvent(event)) {
|
||||
|
||||
/* uncommented for debugging */
|
||||
//printInfo(pad, event);
|
||||
|
||||
handleEvent(event);
|
||||
|
||||
sendControllerPacket(conn);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Prints out the specified event information for the given gamepad
|
||||
* used for debugging, normally unused.
|
||||
*/
|
||||
public static void printInfo(Controller gamepad, Event event) {
|
||||
Component comp = event.getComponent();
|
||||
|
||||
StringBuilder builder = new StringBuilder(gamepad.getName());
|
||||
|
||||
builder.append(" at ");
|
||||
builder.append(event.getNanos()).append(": ");
|
||||
builder.append(comp.getName()).append(" changed to ");
|
||||
|
||||
|
||||
float value = event.getValue();
|
||||
if(comp.isAnalog()) {
|
||||
builder.append(value);
|
||||
} else if (comp.getIdentifier() == Identifier.Axis.POV) {
|
||||
if (value == Component.POV.DOWN) {
|
||||
builder.append("Down");
|
||||
}
|
||||
else if (value == Component.POV.UP) {
|
||||
builder.append("Up");
|
||||
}
|
||||
else if (value == Component.POV.LEFT) {
|
||||
builder.append("Left");
|
||||
}
|
||||
else if (value == Component.POV.RIGHT) {
|
||||
builder.append("Right");
|
||||
}
|
||||
else if (value == Component.POV.CENTER) {
|
||||
builder.append("Center");
|
||||
}
|
||||
else if (value == Component.POV.DOWN_LEFT) {
|
||||
builder.append("Down-left");
|
||||
}
|
||||
else if (value == Component.POV.DOWN_RIGHT) {
|
||||
builder.append("Down-right");
|
||||
}
|
||||
else if (value == Component.POV.UP_LEFT) {
|
||||
builder.append("Up-left");
|
||||
}
|
||||
else if (value == Component.POV.UP_RIGHT) {
|
||||
builder.append("Up-right");
|
||||
}
|
||||
else {
|
||||
builder.append("Unknown");
|
||||
}
|
||||
} else {
|
||||
if(value==1.0f) {
|
||||
builder.append("On");
|
||||
} else {
|
||||
builder.append("Off");
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println(builder.toString());
|
||||
}
|
||||
|
||||
/*
|
||||
* Handles a given event
|
||||
*/
|
||||
private void handleEvent(Event event) {
|
||||
Component comp = event.getComponent();
|
||||
float value = event.getValue();
|
||||
|
||||
handleComponent(comp, value);
|
||||
}
|
||||
|
||||
/*
|
||||
* Handles the component that an event occurred on
|
||||
*/
|
||||
private void handleComponent(Component comp, float value) {
|
||||
Mapping mapping = config.get(comp);
|
||||
if (mapping != null) {
|
||||
if (mapping.contComp.isAnalog()) {
|
||||
handleAnalog(mapping.contComp, sanitizeValue(mapping, value));
|
||||
} else if (comp.getIdentifier() == Component.Identifier.Axis.POV) {
|
||||
// The values are directional constants so they cannot be sanitized
|
||||
handlePOV(value);
|
||||
} else {
|
||||
handleButtons(mapping.contComp, sanitizeValue(mapping, value));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Fixes the value as specified in the mapping, that is inverts if needed, etc.
|
||||
*/
|
||||
private float sanitizeValue(Mapping mapping, float value) {
|
||||
float sanitized = value;
|
||||
if (mapping.invert) {
|
||||
sanitized = -sanitized;
|
||||
}
|
||||
if (mapping.trigger) {
|
||||
sanitized = (sanitized + 1)/2;
|
||||
}
|
||||
return sanitized;
|
||||
private NvConnection conn;
|
||||
|
||||
public Gamepad(NvConnection conn) {
|
||||
this.conn = conn;
|
||||
}
|
||||
|
||||
/*
|
||||
* Toggles a flag that indicates the specified button was pressed or released
|
||||
*/
|
||||
private void toggle(short button, boolean pressed) {
|
||||
if (pressed) {
|
||||
inputMap |= button;
|
||||
} else {
|
||||
inputMap &= ~button;
|
||||
}
|
||||
public Gamepad() {
|
||||
this(null);
|
||||
}
|
||||
|
||||
/*
|
||||
* Handles POV component input
|
||||
*/
|
||||
private void handlePOV(float value) {
|
||||
if (value == Component.POV.UP ||
|
||||
value == Component.POV.UP_LEFT ||
|
||||
value == Component.POV.UP_RIGHT) {
|
||||
toggle(ControllerPacket.UP_FLAG, true);
|
||||
}
|
||||
else {
|
||||
toggle(ControllerPacket.UP_FLAG, false);
|
||||
}
|
||||
|
||||
if (value == Component.POV.DOWN ||
|
||||
value == Component.POV.DOWN_LEFT ||
|
||||
value == Component.POV.DOWN_RIGHT) {
|
||||
toggle(ControllerPacket.DOWN_FLAG, true);
|
||||
}
|
||||
else {
|
||||
toggle(ControllerPacket.DOWN_FLAG, false);
|
||||
}
|
||||
|
||||
if (value == Component.POV.LEFT ||
|
||||
value == Component.POV.DOWN_LEFT ||
|
||||
value == Component.POV.UP_LEFT) {
|
||||
toggle(ControllerPacket.LEFT_FLAG, true);
|
||||
}
|
||||
else {
|
||||
toggle(ControllerPacket.LEFT_FLAG, false);
|
||||
}
|
||||
|
||||
if (value == Component.POV.RIGHT ||
|
||||
value == Component.POV.UP_RIGHT ||
|
||||
value == Component.POV.DOWN_RIGHT) {
|
||||
toggle(ControllerPacket.RIGHT_FLAG, true);
|
||||
}
|
||||
else {
|
||||
toggle(ControllerPacket.RIGHT_FLAG, false);
|
||||
}
|
||||
public void setConnection(NvConnection conn) {
|
||||
this.conn = conn;
|
||||
}
|
||||
|
||||
/*
|
||||
* Handles analog component input
|
||||
*/
|
||||
private void handleAnalog(GamepadComponent contComp, float value) {
|
||||
switch (contComp) {
|
||||
@Override
|
||||
public void handleButton(Device device, int buttonId, boolean pressed) {
|
||||
GamepadMapping mapping = GamepadSettingsManager.getSettings();
|
||||
|
||||
Mapping mapped = mapping.get(new SourceComponent(Type.BUTTON, buttonId));
|
||||
if (mapped == null) {
|
||||
System.out.println("Unmapped button pressed: " + buttonId);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!mapped.contComp.isAnalog()) {
|
||||
handleDigitalComponent(mapped, pressed);
|
||||
} else {
|
||||
handleAnalogComponent(mapped.contComp, sanitizeValue(mapped, pressed));
|
||||
}
|
||||
|
||||
//printInfo(device, new SourceComponent(Type.BUTTON, buttonId), mapped.contComp, pressed ? 1F : 0F);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void handleAxis(Device device, int axisId, float newValue, float lastValue) {
|
||||
GamepadMapping mapping = GamepadSettingsManager.getSettings();
|
||||
|
||||
Mapping mapped = mapping.get(new SourceComponent(Type.AXIS, axisId));
|
||||
if (mapped == null) {
|
||||
System.out.println("Unmapped axis moved: " + axisId);
|
||||
return;
|
||||
}
|
||||
|
||||
float value = sanitizeValue(mapped, newValue);
|
||||
|
||||
if (mapped.contComp.isAnalog()) {
|
||||
handleAnalogComponent(mapped.contComp, value);
|
||||
} else {
|
||||
handleDigitalComponent(mapped, (value > 0.5));
|
||||
}
|
||||
|
||||
//printInfo(device, new SourceComponent(Type.AXIS, axisId), mapped.contComp, newValue);
|
||||
}
|
||||
|
||||
private float sanitizeValue(Mapping mapped, boolean value) {
|
||||
if (mapped.invert) {
|
||||
return value ? 0F : 1F;
|
||||
} else {
|
||||
return value ? 1F : 0F;
|
||||
}
|
||||
}
|
||||
|
||||
private float sanitizeValue(Mapping mapped, float value) {
|
||||
if (mapped.invert) {
|
||||
return -value;
|
||||
} else {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
private void handleAnalogComponent(GamepadComponent padComp, float value) {
|
||||
switch (padComp) {
|
||||
case LS_X:
|
||||
leftStickX = (short)Math.round(value * 0x7FFF);
|
||||
break;
|
||||
@@ -270,70 +113,107 @@ public class Gamepad {
|
||||
rightTrigger = (byte)Math.round(value * 0xFF);
|
||||
break;
|
||||
default:
|
||||
System.out.println("A mapping error has occured. Ignoring: " + contComp.name());
|
||||
System.out.println("A mapping error has occured. Ignoring: " + padComp.name());
|
||||
break;
|
||||
}
|
||||
if (conn != null) {
|
||||
sendControllerPacket();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private void handleDigitalComponent(Mapping mapped, boolean pressed) {
|
||||
switch (mapped.contComp) {
|
||||
case BTN_A:
|
||||
toggle(ControllerPacket.A_FLAG, pressed);
|
||||
break;
|
||||
case BTN_X:
|
||||
toggle(ControllerPacket.X_FLAG, pressed);
|
||||
break;
|
||||
case BTN_Y:
|
||||
toggle(ControllerPacket.Y_FLAG, pressed);
|
||||
break;
|
||||
case BTN_B:
|
||||
toggle(ControllerPacket.B_FLAG, pressed);
|
||||
break;
|
||||
case DPAD_UP:
|
||||
toggle(ControllerPacket.UP_FLAG, pressed);
|
||||
break;
|
||||
case DPAD_DOWN:
|
||||
toggle(ControllerPacket.DOWN_FLAG, pressed);
|
||||
break;
|
||||
case DPAD_LEFT:
|
||||
toggle(ControllerPacket.LEFT_FLAG, pressed);
|
||||
break;
|
||||
case DPAD_RIGHT:
|
||||
toggle(ControllerPacket.RIGHT_FLAG, pressed);
|
||||
break;
|
||||
case LS_THUMB:
|
||||
toggle(ControllerPacket.LS_CLK_FLAG, pressed);
|
||||
break;
|
||||
case RS_THUMB:
|
||||
toggle(ControllerPacket.RS_CLK_FLAG, pressed);
|
||||
break;
|
||||
case LB:
|
||||
toggle(ControllerPacket.LB_FLAG, pressed);
|
||||
break;
|
||||
case RB:
|
||||
toggle(ControllerPacket.RB_FLAG, pressed);
|
||||
break;
|
||||
case BTN_START:
|
||||
toggle(ControllerPacket.PLAY_FLAG, pressed);
|
||||
break;
|
||||
case BTN_BACK:
|
||||
toggle(ControllerPacket.BACK_FLAG, pressed);
|
||||
break;
|
||||
case BTN_SPECIAL:
|
||||
toggle(ControllerPacket.SPECIAL_BUTTON_FLAG, pressed);
|
||||
break;
|
||||
default:
|
||||
System.out.println("A mapping error has occured. Ignoring: " + mapped.contComp.name());
|
||||
return;
|
||||
}
|
||||
if (conn != null) {
|
||||
sendControllerPacket();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Handles button input
|
||||
* Sends a controller packet to the specified connection containing the current gamepad values
|
||||
*/
|
||||
private void handleButtons(GamepadComponent contComp, float value) {
|
||||
boolean press = false;
|
||||
|
||||
if (value > 0.5F) {
|
||||
press = true;
|
||||
}
|
||||
|
||||
switch (contComp) {
|
||||
case BTN_A:
|
||||
toggle(ControllerPacket.A_FLAG, press);
|
||||
break;
|
||||
case BTN_X:
|
||||
toggle(ControllerPacket.X_FLAG, press);
|
||||
break;
|
||||
case BTN_Y:
|
||||
toggle(ControllerPacket.Y_FLAG, press);
|
||||
break;
|
||||
case BTN_B:
|
||||
toggle(ControllerPacket.B_FLAG, press);
|
||||
break;
|
||||
case DPAD_UP:
|
||||
toggle(ControllerPacket.UP_FLAG, press);
|
||||
break;
|
||||
case DPAD_DOWN:
|
||||
toggle(ControllerPacket.DOWN_FLAG, press);
|
||||
break;
|
||||
case DPAD_LEFT:
|
||||
toggle(ControllerPacket.LEFT_FLAG, press);
|
||||
break;
|
||||
case DPAD_RIGHT:
|
||||
toggle(ControllerPacket.RIGHT_FLAG, press);
|
||||
break;
|
||||
case LS_THUMB:
|
||||
toggle(ControllerPacket.LS_CLK_FLAG, press);
|
||||
break;
|
||||
case RS_THUMB:
|
||||
toggle(ControllerPacket.RS_CLK_FLAG, press);
|
||||
break;
|
||||
case LB:
|
||||
toggle(ControllerPacket.LB_FLAG, press);
|
||||
break;
|
||||
case RB:
|
||||
toggle(ControllerPacket.RB_FLAG, press);
|
||||
break;
|
||||
case BTN_START:
|
||||
toggle(ControllerPacket.PLAY_FLAG, press);
|
||||
break;
|
||||
case BTN_BACK:
|
||||
toggle(ControllerPacket.BACK_FLAG, press);
|
||||
break;
|
||||
case BTN_SPECIAL:
|
||||
toggle(ControllerPacket.SPECIAL_BUTTON_FLAG, press);
|
||||
break;
|
||||
default:
|
||||
System.out.println("A mapping error has occured. Ignoring: " + contComp.name());
|
||||
break;
|
||||
private void sendControllerPacket() {
|
||||
if (conn != null) {
|
||||
conn.sendControllerInput(inputMap, leftTrigger, rightTrigger,
|
||||
leftStickX, leftStickY, rightStickX, rightStickY);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Prints out the specified event information for the given gamepad
|
||||
* used for debugging, normally unused.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
private void printInfo(Device device, SourceComponent sourceComp, GamepadComponent padComp, float value) {
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
|
||||
builder.append(sourceComp.getType().name() + ": ");
|
||||
builder.append(sourceComp.getId() + " ");
|
||||
builder.append("mapped to: " + padComp + " ");
|
||||
builder.append("changed to ");
|
||||
|
||||
System.out.println(builder.toString());
|
||||
}
|
||||
|
||||
/*
|
||||
* Toggles a flag that indicates the specified button was pressed or released
|
||||
*/
|
||||
private void toggle(short button, boolean pressed) {
|
||||
if (pressed) {
|
||||
inputMap |= button;
|
||||
} else {
|
||||
inputMap &= ~button;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,114 +0,0 @@
|
||||
package com.limelight.input.gamepad;
|
||||
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.locks.Lock;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
import com.limelight.nvstream.NvConnection;
|
||||
import com.limelight.settings.GamepadSettingsManager;
|
||||
|
||||
import net.java.games.input.Controller;
|
||||
|
||||
/**
|
||||
* A handler for all the gamepads attached to this system
|
||||
* @author Diego Waxemberg
|
||||
*/
|
||||
public class GamepadHandler {
|
||||
private static LinkedList<Gamepad> gamepads = new LinkedList<Gamepad>();
|
||||
private static Lock gamepadLock = new ReentrantLock();
|
||||
private static NvConnection conn;
|
||||
private static Thread handler;
|
||||
private static boolean run = true;
|
||||
|
||||
/**
|
||||
* Adds the list of controllers as gamepads to be handled
|
||||
* @param pads the controllers to be handled as gamepads
|
||||
*/
|
||||
public static void addGamepads(List<Controller> pads) {
|
||||
LinkedList<Gamepad> newPadList = new LinkedList<Gamepad>();
|
||||
|
||||
GamepadMapping settings = GamepadSettingsManager.getSettings();
|
||||
for (Controller pad : pads) {
|
||||
|
||||
newPadList.add(new Gamepad(pad, settings));
|
||||
}
|
||||
|
||||
gamepadLock.lock();
|
||||
gamepads = newPadList;
|
||||
gamepadLock.unlock();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the connection to which the handled gamepads should send events
|
||||
* @param connection the connection to the host
|
||||
*/
|
||||
public static void setConnection(NvConnection connection) {
|
||||
conn = connection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a list of the currently handled gamepads
|
||||
* @return an unmodifiable list of gamepads this handler handles
|
||||
*/
|
||||
public static List<Gamepad> getGamepads() {
|
||||
return Collections.unmodifiableList(gamepads);
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts up a thread that handles the gamepads
|
||||
*/
|
||||
public static void startUp() {
|
||||
if (handler == null || !handler.isAlive()) {
|
||||
run = true;
|
||||
System.out.println("Gamepad Handler thread starting up");
|
||||
handler = new Thread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
while (run) {
|
||||
try {
|
||||
gamepadLock.lockInterruptibly();
|
||||
} catch (InterruptedException e1) {
|
||||
run = false;
|
||||
}
|
||||
for (Gamepad gamepad : gamepads) {
|
||||
if (!gamepad.poll()) {
|
||||
break;
|
||||
}
|
||||
gamepad.handleEvents(conn);
|
||||
}
|
||||
gamepadLock.unlock();
|
||||
try {
|
||||
Thread.sleep(20);
|
||||
} catch (InterruptedException e) {
|
||||
run = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
handler.start();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stops handling the gamepads
|
||||
*/
|
||||
public static void stopHandler() {
|
||||
if (handler != null && handler.isAlive()) {
|
||||
System.out.println("Stopping Gamepad Handler thread");
|
||||
handler.interrupt();
|
||||
conn = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the handler is handling the gamepads.
|
||||
* @return whether this handler is running
|
||||
*/
|
||||
public static boolean isRunning() {
|
||||
return (handler != null && handler.isAlive());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,145 +1,83 @@
|
||||
package com.limelight.input.gamepad;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedList;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.List;
|
||||
|
||||
import com.limelight.nvstream.NvConnection;
|
||||
|
||||
import net.java.games.input.Controller;
|
||||
import net.java.games.input.ControllerEnvironment;
|
||||
import com.limelight.input.Device;
|
||||
import com.limelight.input.DeviceListener;
|
||||
|
||||
/**
|
||||
* Listens to <code>Controller</code>s connected to this computer and gives any gamepad to the gamepad handler
|
||||
* @author Diego Waxemberg
|
||||
*/
|
||||
public class GamepadListener {
|
||||
private static Thread listenerThread;
|
||||
private static NvConnection conn;
|
||||
private static ControllerEnvironment defaultEnv;
|
||||
public class GamepadListener implements NativeGamepadListener {
|
||||
private HashMap<Integer, Device> devices;
|
||||
private List<DeviceListener> listeners;
|
||||
|
||||
/**
|
||||
* starts a thread to listen to controllers
|
||||
* @return true if it started a thread, false if the thread is already running.
|
||||
*/
|
||||
public static boolean startUp() {
|
||||
// Suppress spam from jinput log warnings in DefaultControllerEnvironment
|
||||
Logger.getLogger(ControllerEnvironment.getDefaultEnvironment().getClass().getName()).setLevel(Level.SEVERE);
|
||||
|
||||
if (listenerThread == null || !listenerThread.isAlive()) {
|
||||
System.out.println("Controller Listener thread starting up");
|
||||
listenerThread = new Thread() {
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
|
||||
defaultEnv = ControllerEnvironment.getDefaultEnvironment();
|
||||
|
||||
while(!isInterrupted()) {
|
||||
|
||||
Controller[] ca = defaultEnv.getControllers();
|
||||
LinkedList<Controller> gamepads = new LinkedList<Controller>();
|
||||
private static GamepadListener singleton;
|
||||
|
||||
public static GamepadListener getInstance() {
|
||||
if (singleton == null) {
|
||||
singleton = new GamepadListener();
|
||||
}
|
||||
return singleton;
|
||||
}
|
||||
|
||||
private GamepadListener() {
|
||||
devices = new HashMap<Integer, Device>();
|
||||
listeners = new LinkedList<DeviceListener>();
|
||||
}
|
||||
|
||||
public int deviceCount() {
|
||||
return devices.size();
|
||||
}
|
||||
|
||||
public void addDeviceListener(DeviceListener listener) {
|
||||
listeners.add(listener);
|
||||
}
|
||||
|
||||
public List<DeviceListener> getListeners() {
|
||||
return Collections.unmodifiableList(listeners);
|
||||
}
|
||||
|
||||
public void removeListener(DeviceListener listener) {
|
||||
listeners.remove(listener);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deviceAttached(int deviceId, int numButtons, int numAxes) {
|
||||
devices.put(deviceId, new Device(deviceId, numButtons, numAxes));
|
||||
}
|
||||
|
||||
/*
|
||||
* iterates through the controllers and adds gamepads and ps3 controller to the list
|
||||
* NOTE: JInput does not consider a PS3 controller to be a gamepad (it thinks it's a "STICK") so we must use the
|
||||
* name of it.
|
||||
*/
|
||||
for(int i = 0; i < ca.length; i++){
|
||||
if (ca[i].getType() == Controller.Type.GAMEPAD) {
|
||||
gamepads.add(ca[i]);
|
||||
} else if (ca[i].getName().contains("PLAYSTATION")) {
|
||||
gamepads.add(ca[i]);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public void deviceRemoved(int deviceId) {
|
||||
devices.remove(deviceId);
|
||||
}
|
||||
|
||||
GamepadHandler.addGamepads(gamepads);
|
||||
GamepadHandler.setConnection(conn);
|
||||
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
};
|
||||
listenerThread.start();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is really janky, but it is currently the only way to rescan for controllers.
|
||||
* The DefaultControllerEnvironment class caches the results of scanning and if a controller is
|
||||
* unplugged or plugged in, it will not detect it. Since DefaultControllerEnvironment is package-protected
|
||||
* we have to use reflections in order to create a new instance to scan for controllers
|
||||
*/
|
||||
public static void rescanControllers() {
|
||||
try {
|
||||
System.out.println("Rescanning for controllers...");
|
||||
Constructor<? extends ControllerEnvironment> envConst = ControllerEnvironment.getDefaultEnvironment().getClass().getDeclaredConstructor((Class[])null);
|
||||
envConst.setAccessible(true);
|
||||
defaultEnv = (ControllerEnvironment) envConst.newInstance((Object[])null);
|
||||
} catch (SecurityException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (NoSuchMethodException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (IllegalArgumentException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (InstantiationException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (IllegalAccessException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (InvocationTargetException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Stops listening for controllers, ie. stops the thread if it is running
|
||||
*/
|
||||
public static void stopListening() {
|
||||
if (listenerThread != null && listenerThread.isAlive()) {
|
||||
System.out.println("Stopping Controller Listener thread");
|
||||
listenerThread.interrupt();
|
||||
}
|
||||
if (GamepadHandler.isRunning()) {
|
||||
GamepadHandler.stopHandler();
|
||||
@Override
|
||||
public void buttonDown(int deviceId, int buttonId) {
|
||||
Device dev = devices.get(deviceId);
|
||||
for (DeviceListener listener : listeners) {
|
||||
listener.handleButton(dev, buttonId, true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tells the handler to start sending gamepad events to the specified connection
|
||||
* @param connection the connection to the host that will receive gamepad events
|
||||
*/
|
||||
public static void startSendingInput(NvConnection connection) {
|
||||
System.out.println("Starting to send controller input");
|
||||
conn = connection;
|
||||
if (!GamepadHandler.isRunning()) {
|
||||
GamepadHandler.startUp();
|
||||
|
||||
@Override
|
||||
public void buttonUp(int deviceId, int buttonId) {
|
||||
Device dev = devices.get(deviceId);
|
||||
for (DeviceListener listener : listeners) {
|
||||
listener.handleButton(dev, buttonId, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tells the handler to stop sending events to the host
|
||||
*/
|
||||
public static void stopSendingInput() {
|
||||
System.out.println("Stopping sending controller input");
|
||||
conn = null;
|
||||
|
||||
@Override
|
||||
public void axisMoved(int deviceId, int axisId, float value, float lastValue) {
|
||||
Device dev = devices.get(deviceId);
|
||||
for (DeviceListener listener : listeners) {
|
||||
listener.handleAxis(dev, axisId, value, lastValue);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -4,9 +4,6 @@ import java.io.Serializable;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
|
||||
import net.java.games.input.Component;
|
||||
|
||||
/**
|
||||
* Mappings for gamepad components
|
||||
* @author Diego Waxemberg
|
||||
@@ -14,13 +11,13 @@ import net.java.games.input.Component;
|
||||
public class GamepadMapping implements Serializable {
|
||||
private static final long serialVersionUID = -185035113915743149L;
|
||||
|
||||
private HashMap<String, Mapping> mapping;
|
||||
private HashMap<SourceComponent, Mapping> mapping;
|
||||
|
||||
/**
|
||||
* Constructs a new mapping that has nothing mapped.
|
||||
*/
|
||||
public GamepadMapping() {
|
||||
mapping = new HashMap<String, Mapping>();
|
||||
mapping = new HashMap<SourceComponent, Mapping>();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -29,11 +26,7 @@ public class GamepadMapping implements Serializable {
|
||||
* @param comp the gamepad component to map to.
|
||||
*/
|
||||
public void insertMapping(Mapping toMap, SourceComponent comp) {
|
||||
// This is the base mapping for components with multiple "buttons"
|
||||
mapping.put(comp.getComponentId(), toMap);
|
||||
|
||||
// This is the more-specific mapping for the specific buttons
|
||||
mapping.put(comp.getFullUniqueId(), toMap);
|
||||
mapping.put(comp, toMap);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -41,17 +34,8 @@ public class GamepadMapping implements Serializable {
|
||||
* @param comp the gamepad component to get a mapping for
|
||||
* @return a mapping for the requested component
|
||||
*/
|
||||
public Mapping get(Component comp) {
|
||||
return mapping.get(comp.getIdentifier().getName());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the mapping for the specified source component
|
||||
* @param comp the source component to get a mapping for
|
||||
* @return a mapping for the requested component
|
||||
*/
|
||||
public Mapping get(SourceComponent comp) {
|
||||
return mapping.get(comp.getFullUniqueId());
|
||||
return mapping.get(comp);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -59,27 +43,18 @@ public class GamepadMapping implements Serializable {
|
||||
* @param comp the component to no longer be mapped.
|
||||
*/
|
||||
public void remove(SourceComponent comp) {
|
||||
// Remove the most specific mapping
|
||||
mapping.remove(comp.getFullUniqueId());
|
||||
|
||||
for (Entry<String, Mapping> entry : mapping.entrySet()) {
|
||||
if (entry.getKey().startsWith(comp.getComponentId())) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Remove the common mapping if no more specific mappings remain
|
||||
mapping.remove(comp.getComponentId());
|
||||
mapping.remove(comp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the mapped ControllerComponent for the specified ControllerComponent.</br>
|
||||
* <b>NOTE: Iterates a hashmap, use sparingly</b>
|
||||
* @param contComp the component to get a mapping for
|
||||
* @return a mapping or an null if there is none
|
||||
*/
|
||||
public Mapping get(GamepadComponent contComp) {
|
||||
//#allTheJank
|
||||
for (Entry<String, Mapping> entry : mapping.entrySet()) {
|
||||
for (Entry<SourceComponent, Mapping> entry : mapping.entrySet()) {
|
||||
if (entry.getValue().contComp == contComp) {
|
||||
return entry.getValue();
|
||||
}
|
||||
@@ -89,16 +64,17 @@ public class GamepadMapping implements Serializable {
|
||||
|
||||
/**
|
||||
* Gets the mapping for the specified component.</br>
|
||||
* <b>NOTE: Iterates a hashmap, use sparingly</b>
|
||||
* @param contComp the component to get a mapping for
|
||||
* @return a mapping or an empty string if there is none
|
||||
*/
|
||||
public String getMapping(GamepadComponent contComp) {
|
||||
for (Entry<String, Mapping> entry : mapping.entrySet()) {
|
||||
public SourceComponent getMapping(GamepadComponent contComp) {
|
||||
for (Entry<SourceComponent, Mapping> entry : mapping.entrySet()) {
|
||||
if (entry.getValue().contComp == contComp) {
|
||||
return entry.getKey();
|
||||
}
|
||||
}
|
||||
return "";
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,29 +1,42 @@
|
||||
package com.limelight.input.gamepad;
|
||||
|
||||
import net.java.games.input.Component;
|
||||
|
||||
public class SourceComponent {
|
||||
private Component component;
|
||||
private String id;
|
||||
public enum Type { AXIS, BUTTON }
|
||||
private Type type;
|
||||
private int id;
|
||||
|
||||
public SourceComponent(Component component, String id) {
|
||||
this.component = component;
|
||||
public SourceComponent(Type type, int id) {
|
||||
this.type = type;
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public Component getComponent() {
|
||||
return component;
|
||||
public Type getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
public String getId() {
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public String getFullUniqueId() {
|
||||
return getComponentId() + " " + getId();
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
result = prime * result + id;
|
||||
result = prime * result + ((type == null) ? 0 : type.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if (obj == null || !(obj instanceof SourceComponent)) {
|
||||
return false;
|
||||
}
|
||||
SourceComponent other = (SourceComponent) obj;
|
||||
|
||||
public String getComponentId() {
|
||||
return component.getIdentifier().getName();
|
||||
return id == other.id && type == other.type;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user