diff --git a/java/.classpath b/java/.classpath new file mode 100644 index 0000000..50660d7 --- /dev/null +++ b/java/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/java/.project b/java/.project new file mode 100644 index 0000000..b60ae00 --- /dev/null +++ b/java/.project @@ -0,0 +1,18 @@ + + + java.wiiusej + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.springsource.ide.eclipse.gradle.core.nature + org.eclipse.jdt.core.javanature + + diff --git a/java/build.gradle b/java/build.gradle new file mode 100644 index 0000000..e69de29 diff --git a/java/src/main/java/wiiusej/WiiUseApi.java b/java/src/main/java/wiiusej/WiiUseApi.java new file mode 100644 index 0000000..ccacfea --- /dev/null +++ b/java/src/main/java/wiiusej/WiiUseApi.java @@ -0,0 +1,366 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej; + +import wiiusej.wiiusejevents.utils.EventsGatherer; + +/** + * Singleton used to manipulate WiiUse Api. + * + * @author guiguito + */ +public class WiiUseApi { + + static { + System.loadLibrary("WiiuseJ"); + } + + private static WiiUseApi instance = new WiiUseApi(); + + /** + * Get the only instance of WiiUseApi. + * + * @return the only instace of WiiUseApi. + */ + protected static WiiUseApi getInstance() { + return instance; + } + + /** + * Connect to a wiimote or wiimotes once an address is known. + * + * @param nbWiimotes + * The number of wiimotes. + * @return The number of wiimotes that successfully connected. + */ + synchronized native int connect(int nbWiimotes); + + /** + * Find a wiimote or wiimotes. + * + * @param nbMaxWiimotes + * The number of wiimotes. + * @param timeout + * The number of seconds before the search times out. + * @return The number of wiimotes found. + */ + synchronized native int find(int nbMaxWiimotes, int timeout); + + /** + * Initialize an array of wiimote structures (for the C side of the + * library). + * + * @param nbPossibleWiimotes + * size of the array. + */ + synchronized native void init(int nbPossibleWiimotes); + + /** + * Close connection to the wiimote with the given id. + * + */ + synchronized native void closeConnection(int id); + + /** + * Get unique id of a wiimote in the wiimotes array. Please make sure you + * call an existing index with a wiimote initialized at this index, other + * wise you'll get a wrong value. + * + * @param index + * index of the wiimote in the wiimotes array. + * @return the unid of the wiimote, or a wrong value if the index was false. + * + */ + synchronized native int getUnId(int index); + + /** + * CleanUp Wiiuse API. + */ + synchronized native void cleanUp(); + + /** + * Activate rumble on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void activateRumble(int id); + + /** + * Deactivate rumble on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void deactivateRumble(int id); + + /** + * Activate IR Tracking on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void activateIRTracking(int id); + + /** + * Deactivate IR Tracking on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void deactivateIRTracking(int id); + + /** + * Activate motion sensing on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void activateMotionSensing(int id); + + /** + * Deactivate motion sensing on the wiimote with the given id. + * + * @param id + * the id of the wiimote. + */ + synchronized native void deactivateMotionSensing(int id); + + /** + * Set wiimote leds status. + * + * @param id + * the id of the wiimote concerned. + * @param led1 + * status of led1: True=ON, False=OFF. + * @param led2 + * status of led2: True=ON, False=OFF. + * @param led3 + * status of led3: True=ON, False=OFF. + * @param led4 + * status of led4: True=ON, False=OFF. + */ + synchronized native void setLeds(int id, boolean led1, boolean led2, + boolean led3, boolean led4); + + /** + * Set how many degrees an angle must change to generate an event. + * + * @param id + * id of the wiimote concerned. + * @param angle + * minimum angle detected by an event. + */ + synchronized native void setOrientThreshold(int id, float angle); + + /** + * Set how much acceleration must change to generate an event. + * + * @param id + * id of the wiimote concerned. + * @param value + * minimum value detected by an event. + */ + synchronized native void setAccelThreshold(int id, int value); + + /** + * Set alpha smoothing parameter for the given id. + * + * @param id + * id of the wiimote concerned. + * @param value + * alpha smoothing value. + */ + synchronized native void setAlphaSmoothing(int id, float value); + + /** + * Try to resync with the wiimote by starting a new handshake. + * + * @param id + * id of the wiimote concerned. + */ + synchronized native void reSync(int id); + + /** + * Make the the accelerometers give smoother results. This is set by + * default. + * + * @param id + * the id of the wiimote concerned. + */ + synchronized native void activateSmoothing(int id); + + /** + * Make the the accelerometers give raw results. + * + * @param id + * the id of the wiimote concerned. + */ + synchronized native void deactivateSmoothing(int id); + + /** + * Make the wiimote generate an event each time we poll. Not set by default. + * + * @param id + * the id of the wiimote concerned. + */ + synchronized native void activateContinuous(int id); + + /** + * Make the wiimote generate an event only when there is one. + * + * @param id + * the id of the wiimote concerned. + */ + synchronized native void deactivateContinuous(int id); + + /** + * Notify wiiuse that your screen has an aspect ratio of 4/3. + * + * @param id + * the id of the wiimote of which we want the status. + */ + synchronized native void setScreenRatio43(int id); + + /** + * Notify wiiuse that your screen has an aspect ratio of 16/9. + * + * @param id + * the id of the wiimote of which we want the status. + */ + synchronized native void setScreenRatio169(int id); + + /** + * Notify wiiuse that the sensor bar is above your screen. + * + * @param id + * the id of the wiimote of which we want the status. + */ + synchronized native void setSensorBarAboveScreen(int id); + + /** + * Notify wiiuse that the sensor bar is below your screen. + * + * @param id + * the id of the wiimote of which we want the status. + */ + synchronized native void setSensorBarBelowScreen(int id); + + /** + * Set virtual screen resolution. It is used to automatically compute the + * position of a cursor on this virtual screen using the sensor bar. These + * results come in the IREvent. + * + * @param id + * the id of the wiimote of which we want the status. + * @param x + * x resolution. + * @param y + * y resolution. + */ + synchronized native void setVirtualScreenResolution(int id, int x, int y); + + /** + * Get status and values from the wiimotes and send it through callbacks. + * + * @param id + * the id of the wiimote of which we want the status. + */ + synchronized native void getStatus(int id); + + /** + * Set the normal and expansion handshake timeouts. + * + * @param id + * the id of the wiimote concerned. + * @param normalTimeout + * The timeout in milliseconds for a normal read. + * @param expansionTimeout + * The timeout in millisecondsd to wait for an expansion + * handshake. + */ + synchronized native void setTimeout(int id, short normalTimeout, + short expansionTimeout); + + /** + * Set the IR sensitivity. + * + * @param id + * the id of the wiimote concerned. + * @param level + * 1-5, same as Wii system sensitivity setting. If the level is < + * 1, then level will be set to 1. If the level is > 5, then + * level will be set to 5. + */ + synchronized native void setIrSensitivity(int id, int level); + + /** + * Set how many degrees an angle must change to generate an event for the + * nunchuk. + * + * @param id + * id of the wiimote concerned. + * @param angle + * minimum angle detected by an event. + */ + synchronized native void setNunchukOrientationThreshold(int id, float angle); + + /** + * Set how much acceleration must change to generate an event for the + * nunchuk. + * + * @param id + * id of the wiimote concerned. + * @param value + * minimum value detected by an event. + */ + synchronized native void setNunchukAccelerationThreshold(int id, int value); + + /** + * Force the bluetooth stack type.(useful only for windows) + * + * @param bluetoothStackType + * must be WiiUseApi.WIIUSE_STACK_UNKNOWN or + * WiiUseApi.WIIUSE_STACK_MS or + * WiiUseApi.WIIUSE_STACK_BLUESOLEIL. + */ + native void windowsSetBluetoothStack(int bluetoothStackType); + + /** + * Check for new Events and Get it. + * + * @param gath + * the object where we store all the new events. + */ + native void specialPoll(EventsGatherer gath); + + + /** + * Speaker + */ + native void enableSpeaker(int id); + native void disableSpeaker(int id); + native void muteSpeaker(int id); + native void unmuteSpeaker(int id); + native void activateSpeaker(int id); + native void deactivateSpeaker(int id); + native void setSpeakerFormat(int id, byte format); + native void setSpeakerRate(int id, byte rate, byte freq); + native void setSpeakerVolume(int id, double volume); + native void setSpeakerConfig(int id); + native void streamSpeakerData(int id, byte[] block); +} diff --git a/java/src/main/java/wiiusej/WiiUseApiManager.java b/java/src/main/java/wiiusej/WiiUseApiManager.java new file mode 100644 index 0000000..ba5627d --- /dev/null +++ b/java/src/main/java/wiiusej/WiiUseApiManager.java @@ -0,0 +1,711 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej; + +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicBoolean; + +import javax.swing.event.EventListenerList; + +import wiiusej.wiiusejevents.utils.EventsGatherer; +import wiiusej.wiiusejevents.utils.WiiUseApiListener; +import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent; + +/** + * Class that manages the use of Wiiuse API. + * + * @author guiguito + */ +public class WiiUseApiManager extends Thread { + + private static WiiUseApiManager instance = new WiiUseApiManager(); + + private final EventListenerList listeners = new EventListenerList(); + + private Semaphore semaphore = new Semaphore(0); + + private Wiimote[] wiimotes; + + private WiiUseApi wiiuse = WiiUseApi.getInstance(); + + private int connected = -1; + + private AtomicBoolean running = new AtomicBoolean(false); + + private boolean leave = false; + + public static int WIIUSE_STACK_UNKNOWN = 0; + public static int WIIUSE_STACK_MS = 1; + public static int WIIUSE_STACK_BLUESOLEIL = 2; + + public static WiiUseApiManager getInstance() { + return instance; + } + + /** + * Get wiimotes. Load library if necessary. Connect to wiimotes if + * necessary. Start polling if necessary. Return an array with the connected + * wiimotes. + * + * @param nb + * try to connect nb wiimotes. + * @param rumble + * make the connected wiimotes rumble. + * + * @return an array with connected wiimotes or NULL. + */ + public static Wiimote[] getWiimotes(int nb, boolean rumble) { + return getWiimotesPrivate(nb, rumble, false, WIIUSE_STACK_UNKNOWN); + } + + /** + * Get wiimotes. Load library if necessary. Connect to wiimotes if + * necessary. Start polling if necessary. Return an array with the connected + * wiimotes. + * + * @param nb + * try to connect nb wiimotes. + * @param rumble + * make the connected wiimotes rumble.* + * @param stackType + * the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or + * WiiUseApiManager.WIIUSE_STACK_MS or + * WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL + * + * @return an array with connected wiimotes or NULL. + */ + public static Wiimote[] getWiimotes(int nb, boolean rumble, int stackType) { + return getWiimotesPrivate(nb, rumble, true, stackType); + } + + /** + * Get wiimotes. Load library if necessary. Connect to wiimotes if + * necessary. Start polling if necessary. Return an array with the connected + * wiimotes. + * + * @param nb + * try to connect nb wiimotes. + * @param rumble + * make the connected wiimotes rumble.* + * @param forceStackType + * true if we want to force the stack type. + * @param stackType + * the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or + * WiiUseApiManager.WIIUSE_STACK_MS or + * WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL + * + * @return an array with connected wiimotes or NULL. + */ + private synchronized static Wiimote[] getWiimotesPrivate(int nb, + boolean rumble, boolean forceStackType, int stackType) { + WiiUseApiManager manager = getInstance(); + + if (manager.leave) + return null;// wiiusej definitively stopped + + if (manager.connected <= 0 && !manager.running.get()) { + // connect wiimotes. + int nbWiimotes = manager.connectWiimotes(nb, rumble, + forceStackType, stackType); + manager.wiimotes = new Wiimote[nbWiimotes]; + for (int i = 0; i < nbWiimotes; i++) { + Wiimote wim = new Wiimote(WiiUseApi.getInstance().getUnId(i), + manager); + manager.wiimotes[i] = wim; + manager.addWiiUseApiListener(wim); + } + // Set leds on wiimote + for (Wiimote wiimote : manager.wiimotes) { + int id = wiimote.getId(); + if (id % 4 == 0) { + wiimote.setLeds(true, true, true, true); + } else if (id % 4 == 1) { + wiimote.setLeds(true, false, false, false); + } else if (id % 4 == 2) { + wiimote.setLeds(true, true, false, false); + } else if (id % 4 == 3) { + wiimote.setLeds(true, true, true, false); + } + } + // make the connected wiimotes rumble + if (rumble) { + for (Wiimote wiimote : manager.wiimotes) { + wiimote.activateRumble(); + } + try { + sleep(500); + } catch (InterruptedException e) { + } + for (Wiimote wiimote : manager.wiimotes) { + wiimote.deactivateRumble(); + } + } + } + + if (manager.connected == 0) {// no wiimote connected + // return empty array + return new Wiimote[0]; + } + + if (!manager.isAlive())// start wiiuseJ polling + manager.start(); + + manager.semaphore.release(1); + + return manager.wiimotes; + } + + /** + * Connect wiimote and get the number of wiimotes connected. Supposed to be + * used once. + * + * @param nb + * try to connect nb wiimotes + * @param rumble + * make the connected wiimotes rumble + * @param forceStackType + * true if we want to force the stack type. + * @param stackType + * the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or + * WiiUseApiManager.WIIUSE_STACK_MS or + * WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL + * @return 0 if nothing connected or the number of wiimotes connected. + */ + private int connectWiimotes(int nb, boolean rumble, boolean forceStackType, + int stackType) { + if (connected <= 0) { + int nbWiimotesFound; + wiiuse.init(nb); + // force bluetooth stack type ? + if (forceStackType) + setBlueToothstackType(stackType); + nbWiimotesFound = wiiuse.find(nb, 3); + connected = wiiuse.connect(nbWiimotesFound); + return connected; + } else {// library not loaded, no wiimotes connected + return 0; + } + } + + /** + * Ask the thread to close a connection. + * + * @param id + * id of the wiimote to disconnect. + */ + protected void closeConnection(int id) { + int index = 0; + boolean found = false; + while (index < wiimotes.length && !found) { + if (wiimotes[index]!=null && wiimotes[index].getId() == id) {// we have a wiimote with this + // id + // remove the wiimote + removeWiiUseApiListener(wiimotes[index]); + wiimotes[index] = null; + connected--; + if (connected == 0) {// stop this thread if there is + // no more wiimotes connected. + // stop thread + running.set(false); + } + /* Close connection in wiiuse */ + wiiuse.closeConnection(index); + } + index++; + } + } + + /** + * Get the number of wiimotes connected. + * + * @return the number of wiimotes connected. + */ + public static int getNbConnectedWiimotes() { + return getInstance().connected; + } + + /** + * Stop thread and shutdown wiiuse Api. + */ + public static void shutdown() { + WiiUseApiManager manager = getInstance(); + int pastConnected = manager.connected; + if (manager.connected > 0) { + for (Wiimote wim : manager.wiimotes) { + if (wim != null) + wim.disconnect(); + } + } + manager.running.set(false); + if (pastConnected > 0) { + manager.wiiuse.cleanUp(); + } + } + + /** + * Stop wiiuseJ definitively for this program. It finishes Wiiusej thread + * and shutdown wiiuse API. + */ + public static void definitiveShutdown() { + getInstance().leave = true; + shutdown(); + } + + /** + * Activate the rumble for the wiimote with the given id. + * + * @param id + * id of the wiimote. + */ + protected void activateRumble(int id) { + wiiuse.activateRumble(id); + } + + /** + * Deactivate the rumble for the wiimote with the given id. + * + * @param id + * id of the wiimote. + */ + protected void deactivateRumble(int id) { + wiiuse.deactivateRumble(id); + } + + /** + * Activate IR Tracking for the wiimote with the given id. + * + * @param id + * id of the wiimote. + */ + protected void activateIRTRacking(int id) { + wiiuse.activateIRTracking(id); + } + + /** + * Deactivate IR Tracking for the wiimote with the given id. + * + * @param id + * id of the wiimote. + */ + protected void deactivateIRTRacking(int id) { + wiiuse.deactivateIRTracking(id); + } + + /** + * Activate motion sensing for the wiimote with the given id. + * + * @param id + * id of the wiimote. + */ + protected void activateMotionSensing(int id) { + wiiuse.activateMotionSensing(id); + } + + /** + * Deactivate motion sensing for the wiimoter with the given id. + * + * @param id + * id of the wiimote. + */ + protected void deactivateMotionSensing(int id) { + wiiuse.deactivateMotionSensing(id); + } + + /** + * Activate smoothing the wiimotes with the given id. + * + * @param id + * id of the wiimote. + */ + protected void activateSmoothing(int id) { + wiiuse.activateSmoothing(id); + } + + /** + * Deactivate smoothing the wiimotes with the given id. + * + * @param id + * id of the wiimote. + */ + protected void deactivateSmoothing(int id) { + wiiuse.deactivateSmoothing(id); + } + + /** + * Activate continuous for the wiimotes with the given id. + * + * @param id + * id of the wiimote. + */ + protected void activateContinuous(int id) { + wiiuse.activateContinuous(id); + } + + /** + * Deactivate continuous for the wiimotes with the given id. + * + * @param id + * id of the wiimote. + */ + protected void deactivateContinuous(int id) { + wiiuse.deactivateContinuous(id); + } + + /** + * Set leds for the wiimotes with the given id. + * + * @param id + * id of the wiimote + * @param l1 + * status of led1. True : ON, False : OFF. + * @param l2 + * status of led2. True : ON, False : OFF. + * @param l3 + * status of led3. True : ON, False : OFF. + * @param l4 + * status of led4. True : ON, False : OFF. + */ + protected void setLeds(int id, boolean l1, boolean l2, boolean l3, + boolean l4) { + wiiuse.setLeds(id, l1, l2, l3, l4); + } + + /** + * Set the orientation threshold for the given id. (minimum angle between + * two events) + * + * @param id + * id of the wiimote. + * @param th + * threshold in degrees. + */ + protected void setOrientationThreshold(int id, float th) { + wiiuse.setOrientThreshold(id, th); + } + + /** + * Set the acceleration threshold for the given id. (minimum angle between + * two events) + * + * @param id + * id of the wiimote. + * @param th + * threshold. + */ + protected void setAccelerationThreshold(int id, int th) { + wiiuse.setAccelThreshold(id, th); + } + + /** + * Set alpha smoothing for the given id. + * + * @param id + * id of the wiimote. + * @param th + * threshold. + */ + protected void setAlphaSmoothing(int id, float th) { + wiiuse.setAlphaSmoothing(id, th); + } + + /** + * Try to resync with the wiimote by starting a new handshake. + * + * @param id + * id of the wiimote. + */ + protected void reSync(int id) { + wiiuse.reSync(id); + } + + /** + * Set screen aspect ratio to 4/3 for the given id. + * + * @param id + * id of the wiimote. + */ + protected void setScreenAspectRatio43(int id) { + wiiuse.setScreenRatio43(id); + } + + /** + * Set screen aspect ratio to 16/9 for the given id. + * + * @param id + * id of the wiimote. + */ + protected void setScreenAspectRatio169(int id) { + wiiuse.setScreenRatio169(id); + } + + /** + * Set the sensor bar to be above the screen. + * + * @param id + * id of the wiimote. + */ + protected void setSensorBarAboveScreen(int id) { + wiiuse.setSensorBarAboveScreen(id); + } + + /** + * Set the sensor bar to be below the screen. + * + * @param id + * id of the wiimote. + */ + protected void setSensorBarBelowScreen(int id) { + wiiuse.setSensorBarBelowScreen(id); + } + + /** + * Set virtual resolution. It is used to automatically compute the position + * of a cursor on this virtual screen using the sensor bar. These results + * come in the IREvent. + * + * @param id + * id of the wiimote. + * @param x + * x resolution. + * @param y + * y resolution. + */ + protected void setVirtualResolution(int id, int x, int y) { + wiiuse.setVirtualScreenResolution(id, x, y); + } + + /** + * Get Status for the wiimote for the given id. + * + * @param id + * id of the wiimote. + */ + protected void getStatus(int id) { + wiiuse.getStatus(id); + } + + /** + * Set the normal and expansion handshake timeouts. + * + * @param id + * the id of the wiimote concerned. + * @param normalTimeout + * The timeout in milliseconds for a normal read. + * @param expansionTimeout + * The timeout in millisecondsd to wait for an expansion + * handshake. + */ + protected void setTimeout(int id, short normalTimeout, + short expansionTimeout) { + wiiuse.setTimeout(id, normalTimeout, expansionTimeout); + } + + /** + * Set the IR sensitivity. + * + * @param id + * the id of the wiimote concerned. + * @param level + * 1-5, same as Wii system sensitivity setting. If the level is < + * 1, then level will be set to 1. If the level is > 5, then + * level will be set to 5. + */ + protected void setIrSensitivity(int id, int level) { + wiiuse.setIrSensitivity(id, level); + } + + /** + * Set the nunchuk orientation threshold for the given id. (minimum angle + * between two events) + * + * @param id + * id of the wiimote. + * @param th + * threshold in degrees. + */ + protected void setNunchukOrientationThreshold(int id, float th) { + wiiuse.setNunchukOrientationThreshold(id, th); + } + + /** + * Set the nunchuk acceleration threshold for the given id. (minimum angle + * between two events) + * + * @param id + * id of the wiimote. + * @param th + * threshold. + */ + protected void setNunchukAccelerationThreshold(int id, int th) { + wiiuse.setNunchukAccelerationThreshold(id, th); + } + + /** + * Force the bluetooth stack type.(useful only for windows) + * + * @param type + * must be WIIUSE_STACK_UNKNOWN or WIIUSE_STACK_MS or + * WIIUSE_STACK_BLUESOLEIL. + */ + private void setBlueToothstackType(int type) { + wiiuse.windowsSetBluetoothStack(type); + } + + @Override + public void run() { + + while (!leave) { + try { + semaphore.acquire(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + if (connected > 0) { + running.set(true); + + EventsGatherer gather = new EventsGatherer(connected); + + // Start polling and tell the observers when there are Wiimote + // events + while (running.get() && connected > 0) { + + /* Polling */ + wiiuse.specialPoll(gather); + + /* deal with events gathered in Wiiuse API */ + for (WiiUseApiEvent evt : gather.getEvents()) { + if (evt.getWiimoteId() != -1) {// event filled + // there is an event notify observers + notifyWiiUseApiListener(evt); + if (evt.getEventType() == WiiUseApiEvent.DISCONNECTION_EVENT) { + // check if it was a disconnection + // in this case disconnect the wiimote + closeConnection(evt.getWiimoteId()); + } + } else { + System.out + .println("There is an event with id == -1 ??? there is a problem !!! : " + + evt); + } + } + gather.clearEvents(); + } + }/* else { + if (connected <= 0) { + System.out.println("No wiimotes connected !"); + } + }*/ + }// end while true + } + + /** + * Add WiiUseApiListener to the listeners list. + * + * @param listener + * a WiiUseApiListener + */ + protected void addWiiUseApiListener(WiiUseApiListener listener) { + listeners.add(WiiUseApiListener.class, listener); + } + + /** + * Remove WiiUseApiListener from the listeners list. + * + * @param listener + * a WiiUseApiListener + */ + protected void removeWiiUseApiListener(WiiUseApiListener listener) { + listeners.remove(WiiUseApiListener.class, listener); + } + + /** + * Get the list of WiiUseApiListeners. + * + * @return the list of WiiUseApiListeners. + */ + protected WiiUseApiListener[] getWiiUseApiListeners() { + return listeners.getListeners(WiiUseApiListener.class); + } + + /** + * Notify WiiUseApiListeners that an event occured. + * + * @param evt + * GenericEvent occured + */ + private void notifyWiiUseApiListener(WiiUseApiEvent evt) { + for (WiiUseApiListener listener : getWiiUseApiListeners()) { + listener.onWiiUseApiEvent(evt); + } + } + + /** + * Called by the garbage collector at the end. + */ + protected void finalize() throws Throwable { + shutdown(); + } + + /** + * Speaker + */ + public void enableSpeaker(int id) { + wiiuse.enableSpeaker(id); + } + + public void disableSpeaker(int id) { + wiiuse.disableSpeaker(id); + } + + public void muteSpeaker(int id) { + wiiuse.muteSpeaker(id); + } + + public void unmuteSpeaker(int id) { + wiiuse.unmuteSpeaker(id); + } + + public void activateSpeaker(int id) { + wiiuse.activateSpeaker(id); + } + + public void deactivateSpeaker(int id) { + wiiuse.deactivateSpeaker(id); + } + + public void setSpeakerFormat(int id, byte format) { + wiiuse.setSpeakerFormat(id, format); + } + + public void setSpeakerRate(int id, byte rate, byte freq) { + wiiuse.setSpeakerRate(id, rate, freq); + } + + public void setSpeakerVolume(int id, double volume) { + wiiuse.setSpeakerVolume(id, volume); + } + + public void setSpeakerConfig(int id) { + wiiuse.setSpeakerConfig(id); + } + + public void streamSpeakerData(int id, byte[] block) { + wiiuse.streamSpeakerData(id, block); + + } +} diff --git a/java/src/main/java/wiiusej/Wiimote.java b/java/src/main/java/wiiusej/Wiimote.java new file mode 100644 index 0000000..4de7026 --- /dev/null +++ b/java/src/main/java/wiiusej/Wiimote.java @@ -0,0 +1,569 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej; + +import javax.swing.event.EventListenerList; + +import wiiusej.wiiusejevents.utils.WiiUseApiListener; +import wiiusej.wiiusejevents.utils.WiimoteListener; +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent; +import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent; +import wiiusej.wiiusejevents.wiiuseapievents.WiimoteEvent; + +/** + * Class that represents a wiimote. You can register as an observer of this + * wiimote to listen events from it. You manage it. + * + * @author guiguito + */ +public class Wiimote implements WiiUseApiListener { + + private int id = -1;// wiimote id + + private EventListenerList listeners = new EventListenerList(); + + private WiiUseApiManager manager; + + /** + * Constructor. + * + * @param idd + * id of the wiimote + * @param manager + * manager wo built it. + */ + public Wiimote(int idd, WiiUseApiManager manager) { + id = idd; + this.manager = manager; + } + + /** + * Get the unique id of the wiimote. + * + * @return the id + */ + public int getId() { + return id; + } + + /** + * Disconnect this wiimote. + */ + public void disconnect() { + deactivateIRTRacking(); + deactivateMotionSensing(); + deactivateRumble(); + manager.closeConnection(id); + } + + /** + * Activate the rumble. + */ + public void activateRumble() { + manager.activateRumble(id); + } + + /** + * Deactivate the rumble. + */ + public void deactivateRumble() { + manager.deactivateRumble(id); + } + + /** + * Activate IR Tracking. + */ + public void activateIRTRacking() { + manager.activateIRTRacking(id); + } + + /** + * Deactivate IR Tracking. + */ + public void deactivateIRTRacking() { + manager.deactivateIRTRacking(id); + } + + /** + * Activate motion sensing. + */ + public void activateMotionSensing() { + manager.activateMotionSensing(id); + } + + /** + * Deactivate motion sensing. + */ + public void deactivateMotionSensing() { + manager.deactivateMotionSensing(id); + } + + /** + * Activate smoothing. + */ + public void activateSmoothing() { + manager.activateSmoothing(id); + } + + /** + * Deactivate smoothing. + */ + public void deactivateSmoothing() { + manager.deactivateSmoothing(id); + } + + /** + * Activate continuous. + */ + public void activateContinuous() { + manager.activateContinuous(id); + } + + /** + * Deactivate continuous. + */ + public void deactivateContinuous() { + manager.deactivateContinuous(id); + + } + + /** + * Set leds status. + * + * @param l1 + * status of led1. True : ON, False : OFF + * @param l2 + * status of led2. True : ON, False : OFF + * @param l3 + * status of led3. True : ON, False : OFF + * @param l4 + * status of led4. True : ON, False : OFF + */ + public void setLeds(boolean l1, boolean l2, boolean l3, boolean l4) { + manager.setLeds(id, l1, l2, l3, l4); + } + + /** + * Set the orientation threshold (minimum angle between two degrees with + * accelerometer). + * + * @param th + * threshold in degrees + */ + public void setOrientationThreshold(float th) { + manager.setOrientationThreshold(id, th); + } + + /** + * Set the acceleration threshold(minimum angle between two degrees with + * accelerometer). + * + * @param th + * threshold + */ + public void setAccelerationThreshold(int th) { + manager.setAccelerationThreshold(id, th); + } + + /** + * Set the alpha smoothing value. + * + * @param th + * threshold + */ + public void setAlphaSmoothingValue(float th) { + manager.setAlphaSmoothing(id, th); + } + + /** + * Set the screen aspect ratio to be considered as 4/3. + */ + public void setScreenAspectRatio43() { + manager.setScreenAspectRatio43(id); + } + + /** + * Set the screen aspect ratio to be considered as 16/9. + */ + public void setScreenAspectRatio169() { + manager.setScreenAspectRatio169(id); + } + + /** + * Set the sensor bar to be considered above the screen. + */ + public void setSensorBarAboveScreen() { + manager.setSensorBarAboveScreen(id); + } + + /** + * Set the sensor bar to be considered below the screen. + */ + public void setSensorBarBelowScreen() { + manager.setSensorBarBelowScreen(id); + } + + /** + * Set the screen resolution of the you are pointing at with your wiimote. + * + * @param x + * x resolution. + * @param y + * y resolution. + */ + public void setVirtualResolution(int x, int y) { + manager.setVirtualResolution(id, x, y); + } + + /** + * Set the nunchuk orientation threshold for the given id. (minimum angle + * between two events) + * + * @param th + * threshold in degrees. + */ + public void setNunchukOrientationThreshold(float th) { + manager.setNunchukOrientationThreshold(id, th); + } + + /** + * Set the nunchuk acceleration threshold for the given id. (minimum angle + * between two events) + * + * @param th + * threshold. + */ + public void setNunchukAccelerationThreshold(int th) { + manager.setNunchukAccelerationThreshold(id, th); + } + + /** + * Try to resync the wiimote by starting a new handshake. + */ + public void reSync() { + manager.reSync(id); + } + + /** + * Ask for the status of the wiimote. The result will be received in a + * status event object. Implements onStatusEvent on wiimote listener to get + * it. + */ + public void getStatus() { + manager.getStatus(id); + } + + /** + * Set the normal and expansion handshake timeouts for this wiimote. Normal + * time out is for classic polling. The expansion timeout is used when an + * expansion is detected until the expansion successfully handshakes. + * + * @param normalTimeout + * The timeout in milliseconds for a normal read. + * @param expansionTimeout + * The timeout in millisecondsd to wait for an expansion + * handshake. + */ + public void setTimeout(short normalTimeout, short expansionTimeout) { + manager.setTimeout(id, normalTimeout, expansionTimeout); + } + + /** + * Set the IR sensitivity. + * + * @param level + * 1-5, same as Wii system sensitivity setting. If the level is < + * 1, then level will be set to 1. If the level is > 5, then + * level will be set to 5. + */ + public void setIrSensitivity(int level) { + manager.setIrSensitivity(id, level); + } + + /** + * Method called when a WiiUseApiEvent occurs. + * + * @param e + * the WiiUseApiEvent. + */ + public void onWiiUseApiEvent(WiiUseApiEvent e) { + if (e.getWiimoteId() == id) { + if (e.getEventType() == WiiUseApiEvent.GENERIC_EVENT) { + notifyWiiMoteEventListeners((WiimoteEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.STATUS_EVENT) { + notifyStatusEventListeners((StatusEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.DISCONNECTION_EVENT) { + notifyDisconnectionEventListeners((DisconnectionEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_INSERTED) { + notifyNunchukInsertedEventListeners((NunchukInsertedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_REMOVED) { + notifyNunchukRemovedEventListeners((NunchukRemovedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_INSERTED) { + notifyGuitarHeroInsertedEventListeners((GuitarHeroInsertedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_REMOVED) { + notifyGuitarHeroRemovedEventListeners((GuitarHeroRemovedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_INSERTED) { + notifyClassicControllerInsertedEventListeners((ClassicControllerInsertedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_REMOVED) { + notifyClassicControllerRemovedEventListeners((ClassicControllerRemovedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_BALANCE_BOARD_CTRL_INSERTED) { + notifyBalanceBoardInsertedEventListeners((BalanceBoardInsertedEvent) e); + } else if (e.getEventType() == WiiUseApiEvent.WIIUSE_BALANCE_BOARD_CTRL_REMOVED) { + notifyBalanceBoardRemovedEventListeners((BalanceBoardRemovedEvent) e); + } + /* + * events not managed yet || e.getEventType() == WIIUSE_READ_DATA + * WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_INSERTED || e.getEventType() == + * WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_REMOVED || e.getEventType() == + * WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_INSERTED || + * e.getEventType() == + * WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_REMOVED + */ + } + } + + /** + * Add a WiimoteListener to the listeners list. + * + * @param listener + * a WiimoteListener + */ + public void addWiiMoteEventListeners(WiimoteListener listener) { + listeners.add(WiimoteListener.class, listener); + } + + /** + * Remove a WiimoteListener from the listeners list. + * + * @param listener + * a WiimoteListener + */ + public void removeWiiMoteEventListeners(WiimoteListener listener) { + listeners.remove(WiimoteListener.class, listener); + } + + /** + * Get the list of WiimoteListener. + * + * @return the list of WiimoteListener. + */ + public WiimoteListener[] getWiiMoteEventListeners() { + return listeners.getListeners(WiimoteListener.class); + } + + /** + * Notify WiimoteListeners that an event occured. Notify in first the + * listeners for Buttons Events. In second the listeners for IR Events. In + * third the listeners for Motion sensing events. + * + * @param evt + * GenericEvent occured + */ + private void notifyWiiMoteEventListeners(WiimoteEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onButtonsEvent(evt.getButtonsEvent()); + if (evt.isThereIrEvent()) { + listener.onIrEvent(evt.getIREvent()); + } + if (evt.isThereMotionSensingEvent()) { + listener.onMotionSensingEvent(evt.getMotionSensingEvent()); + } + if (evt.isThereExpansionEvent()) { + listener.onExpansionEvent(evt.getExpansionEvent()); + } + } + } + + /** + * Notify WiimoteListener that a status event occured. + * + * @param evt + * status event occured + */ + private void notifyStatusEventListeners(StatusEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onStatusEvent(evt); + } + } + + /** + * Notify WiimoteListener that a disconnection event occured. + * + * @param evt + * disconnection event occured + */ + private void notifyDisconnectionEventListeners(DisconnectionEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onDisconnectionEvent(evt); + } + } + + /** + * Notify WiimoteListener that a NunchukInserted Event occured. + * + * @param evt + * NunchukInserted Event occured + */ + private void notifyNunchukInsertedEventListeners(NunchukInsertedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onNunchukInsertedEvent(evt); + } + } + + /** + * Notify WiimoteListener that a NunchukRemoved Event occured. + * + * @param evt + * NunchukRemoved Event occured + */ + private void notifyNunchukRemovedEventListeners(NunchukRemovedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onNunchukRemovedEvent(evt); + } + } + + /** + * Notify WiimoteListener that a GuitarHeroInserted Event occured. + * + * @param evt + * GuitarHeroInserted Event occured + */ + private void notifyGuitarHeroInsertedEventListeners(GuitarHeroInsertedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onGuitarHeroInsertedEvent(evt); + } + } + + /** + * Notify WiimoteListener that a GuitarHeroRemoved Event occured. + * + * @param evt + * GuitarHeroRemoved Event occured + */ + private void notifyGuitarHeroRemovedEventListeners(GuitarHeroRemovedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onGuitarHeroRemovedEvent(evt); + } + } + + /** + * Notify WiimoteListener that a ClassicControllerInserted Event occured. + * + * @param evt + * ClassicControllerInserted Event occured + */ + private void notifyClassicControllerInsertedEventListeners(ClassicControllerInsertedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onClassicControllerInsertedEvent(evt); + } + } + + /** + * Notify WiimoteListener that a ClassicControllerRemoved Event occured. + * + * @param evt + * ClassicControllerRemoved Event occured + */ + private void notifyClassicControllerRemovedEventListeners(ClassicControllerRemovedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onClassicControllerRemovedEvent(evt); + } + } + + protected void notifyBalanceBoardInsertedEventListeners(BalanceBoardInsertedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onBalanceBoardInsertedEvent(evt); + } + } + + protected void notifyBalanceBoardRemovedEventListeners(BalanceBoardRemovedEvent evt) { + for (WiimoteListener listener : getWiiMoteEventListeners()) { + listener.onBalanceBoardRemovedEvent(evt); + } + } + + @Override + public String toString() { + return "Wiimote with ID : " + id; + } + + public void rumble(int milliseconds) { + activateRumble(); + try { + Thread.sleep(milliseconds); + } catch (InterruptedException e) { + } finally { + deactivateRumble(); + } + } + + /** + * Speaker + */ + public void enableSpeaker() { + manager.enableSpeaker(id); + } + + public void disableSpeaker() { + manager.disableSpeaker(id); + } + + public void muteSpeaker() { + manager.muteSpeaker(id); + } + + public void unmuteSpeaker() { + manager.unmuteSpeaker(id); + } + + public void activateSpeaker() { + manager.activateSpeaker(id); + } + + public void deactivateSpeaker() { + manager.deactivateSpeaker(id); + } + + public void setSpeakerFormat(byte format) { + manager.setSpeakerFormat(id, format); + } + + public void setSpeakerRate(byte rate, byte freq) { + manager.setSpeakerRate(id, rate, freq); + } + + public void setSpeakerVolume(double volume) { + manager.setSpeakerVolume(id, volume); + } + + public void setSpeakerConfig() { + manager.setSpeakerConfig(id); + } + + public void streamSpeakerData(byte[] block) { + manager.streamSpeakerData(id, block); + } +} diff --git a/java/src/main/java/wiiusej/values/Acceleration.java b/java/src/main/java/wiiusej/values/Acceleration.java new file mode 100644 index 0000000..40e7573 --- /dev/null +++ b/java/src/main/java/wiiusej/values/Acceleration.java @@ -0,0 +1,33 @@ +package wiiusej.values; + +public class Acceleration { + protected double x; + protected double y; + protected double z; + + public Acceleration(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; + } + + public double getX() { + return x; + } + + public double getY() { + return y; + } + + public double getZ() { + return y; + } + + public double[] toArray() { + return new double[] {getX(), getY(), getZ()}; + } + + public String toString() { + return "Acceleration : (" + x + ", " + y + ", " + z + ")"; + } +} diff --git a/java/src/main/java/wiiusej/values/Calibration.java b/java/src/main/java/wiiusej/values/Calibration.java new file mode 100644 index 0000000..567929d --- /dev/null +++ b/java/src/main/java/wiiusej/values/Calibration.java @@ -0,0 +1,31 @@ +package wiiusej.values; + +public class Calibration { + protected RawAcceleration zeroAcceleration; + protected RawAcceleration gAcceleration; + protected RawAcceleration differenceAcceleration; + + public Calibration(RawAcceleration zeroAcceleration, RawAcceleration gAcceleration) { + this.zeroAcceleration = zeroAcceleration; + this.gAcceleration = gAcceleration; + differenceAcceleration = new RawAcceleration( + (short) (gAcceleration.getX() - zeroAcceleration.getX()), + (short) (gAcceleration.getY() - zeroAcceleration.getY()), + (short) (gAcceleration.getZ() - zeroAcceleration.getZ())); + } + + public RawAcceleration getZeroAcceleration() { + return zeroAcceleration; + } + + public RawAcceleration getGAcceleration() { + return gAcceleration; + } + + public Acceleration getAcceleration(RawAcceleration rawAcceleration) { + return new Acceleration( + (rawAcceleration.getX() - zeroAcceleration.getX()) / (double) differenceAcceleration.getX(), + (rawAcceleration.getY() - zeroAcceleration.getY()) / (double) differenceAcceleration.getY(), + (rawAcceleration.getZ() - zeroAcceleration.getZ()) / (double) differenceAcceleration.getZ()); + } +} diff --git a/java/src/main/java/wiiusej/values/GForce.java b/java/src/main/java/wiiusej/values/GForce.java new file mode 100644 index 0000000..1b06941 --- /dev/null +++ b/java/src/main/java/wiiusej/values/GForce.java @@ -0,0 +1,83 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.values; + +import java.io.Serializable; + +/** + * Represents gravity force on each axis. + * + * @author guiguito + */ +public class GForce implements Serializable { + protected static final long serialVersionUID = 1L; + + private float x; + private float y; + private float z; + + /** + * Default constructor; + */ + public GForce() { + x = 0; + y = 0; + z = 0; + } + + /** + * Constructor with gravity force on each axis. + * + * @param xx + * x value + * @param yy + * x value + * @param zz + * x value + */ + public GForce(float xx, float yy, float zz) { + x = xx; + y = yy; + z = zz; + } + + /** + * @return the x + */ + public float getX() { + return x; + } + + /** + * @return the y + */ + public float getY() { + return y; + } + + /** + * @return the z + */ + public float getZ() { + return z; + } + + @Override + public String toString() { + return "Gravity force : (" + x + ", " + y + "," + z + ")"; + } +} diff --git a/java/src/main/java/wiiusej/values/IRSource.java b/java/src/main/java/wiiusej/values/IRSource.java new file mode 100644 index 0000000..fc4790a --- /dev/null +++ b/java/src/main/java/wiiusej/values/IRSource.java @@ -0,0 +1,106 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.values; + +/** + * Class used for IR sources. + * + * @author guiguito + */ +public class IRSource { + + private int x; + private int y; + private short rx; + private short ry; + private short size; + + /** + * Build an IR source with all details. + * + * @param xx + * xx interpolated coordinates. + * @param yy + * yy interpolated coordinates. + * @param rxx + * raw X coordinate (0-1023). + * @param ryy + * raw Y coordinate (0-1023). + * @param si + * size of the IR dot (0-15). + */ + public IRSource(int xx, int yy, short rxx, short ryy, short si) { + x = xx; + y = yy; + rx = rxx; + ry = ryy; + size = si; + } + + /** + * Return x interpolated coordinates. + * + * @return the x + */ + public int getX() { + return x; + } + + /** + * Return y interpolated coordinates. + * + * @return the y + */ + public int getY() { + return y; + } + + /** + * Return raw X coordinate (0-1023). + * + * @return the rx + */ + public short getRx() { + return rx; + } + + /** + * Return raw Y coordinate (0-1023). + * + * @return the ry + */ + public short getRy() { + return ry; + } + + /** + * Return size of the IR dot (0-15). + * + * @return the size + */ + public short getSize() { + return size; + } + + @Override + public String toString() { + return "Interpolated coordinates (" + x + "," + y + + "), Raw coordinates(" + rx + "," + ry + "), source size : " + + size + ")"; + } + +} diff --git a/java/src/main/java/wiiusej/values/Orientation.java b/java/src/main/java/wiiusej/values/Orientation.java new file mode 100644 index 0000000..0dad615 --- /dev/null +++ b/java/src/main/java/wiiusej/values/Orientation.java @@ -0,0 +1,120 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.values; + +import java.io.Serializable; + +/** + * Class that represents the orientation of the wiimote. + * + * @author guiguito + */ +public class Orientation implements Serializable { + protected static final long serialVersionUID = 1L; + + private float roll; + private float pitch; + private float yaw; + private float a_roll; + private float a_pitch; + + /** + * Default constructor. + */ + public Orientation() { + roll = 0; + pitch = 0; + yaw = 0; + a_roll = 0; + a_pitch = 0; + } + + /** + * Contructor with raw, pitch , yaw. + * + * @param r + * roll (can be smoothed) + * @param p + * pitch (can be smoothed) + * @param y + * yaw + * @param ar + * absolute roll + * @param ap + * absolute pitch + */ + public Orientation(float r, float p, float y, float ar, float ap) { + roll = r; + pitch = p; + yaw = y; + a_roll = ar; + a_pitch = ap; + } + + /** + * Get the roll (can be smoothed). + * + * @return the roll + */ + public float getRoll() { + return roll; + } + + /** + * Get the pitch (can be smoothed). + * + * @return the pitch + */ + public float getPitch() { + return pitch; + } + + /** + * Get the yaw. + * + * @return the yaw + */ + public float getYaw() { + return yaw; + } + + /** + * Get absolute roll (can not be smoothed). + * + * @return the a_roll + */ + public float getARoll() { + return a_roll; + } + + /** + * Get absolute pitch (can not be smoothed). + * + * @return the a_pitch + */ + public float getAPitch() { + return a_pitch; + } + + @Override + public String toString() { + return "Orientation : (roll: " + roll + ", pitch: " + pitch + ", yaw: " + + yaw + ", absolute roll: " + a_roll + ", absolute pitch: " + + a_pitch + ")"; + } + +} diff --git a/java/src/main/java/wiiusej/values/RawAcceleration.java b/java/src/main/java/wiiusej/values/RawAcceleration.java new file mode 100644 index 0000000..54b60b1 --- /dev/null +++ b/java/src/main/java/wiiusej/values/RawAcceleration.java @@ -0,0 +1,84 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.values; + +import java.io.Serializable; + +/** + * Represents raw acceleration on each axis. + * + * @author guiguito + */ +public class RawAcceleration implements Serializable { + protected static final long serialVersionUID = 1L; + + private short x; + private short y; + private short z; + + /** + * Default constructor; + */ + public RawAcceleration() { + x = 0; + y = 0; + z = 0; + } + + /** + * Constructor with raw acceleration on each axis. + * + * @param xx + * x value + * @param yy + * x value + * @param zz + * x value + */ + public RawAcceleration(short xx, short yy, short zz) { + x = xx; + y = yy; + z = zz; + } + + /** + * @return the x + */ + public short getX() { + return x; + } + + /** + * @return the y + */ + public short getY() { + return y; + } + + /** + * @return the z + */ + public short getZ() { + return z; + } + + @Override + public String toString() { + return "Raw acceleration : (" + x + ", " + y + ", " + z + ")"; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/GenericEvent.java b/java/src/main/java/wiiusej/wiiusejevents/GenericEvent.java new file mode 100644 index 0000000..19ecaff --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/GenericEvent.java @@ -0,0 +1,62 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents; + +import java.io.Serializable; + +/** + * Abstract mother class representing an event with a wiimote id. + * + * @author guiguito + */ +public abstract class GenericEvent implements Serializable { + protected static final long serialVersionUID = 1L; + + /* ID */ + private int wiimoteId = -1; + + /** + * Construct the WiiUseApiEvent setting up the id. + * + * @param id + * the Wiimote id + */ + public GenericEvent(int id) { + wiimoteId = id; + } + + /** + * Get Wiimote ID + * + * @return the wiimote id. + */ + public int getWiimoteId() { + return wiimoteId; + } + + /** + * Set Wiimote ID + * + * @param wiimoteId + * id of the wiimote + */ + void setWiimoteId(int wiimoteId) { + this.wiimoteId = wiimoteId; + } + + public abstract String toString(); +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardButtonsEvent.java new file mode 100644 index 0000000..8c5cd0e --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardButtonsEvent.java @@ -0,0 +1,11 @@ +package wiiusej.wiiusejevents.physicalevents; + +public class BalanceBoardButtonsEvent extends ButtonsEvent { + protected static short BALANCE_BOARD_BUTTON = 0x0001; + + public BalanceBoardButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardEvent.java new file mode 100644 index 0000000..4c3c643 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/BalanceBoardEvent.java @@ -0,0 +1,31 @@ +package wiiusej.wiiusejevents.physicalevents; + +public class BalanceBoardEvent extends ExpansionEvent { + protected JoystickEvent balanceBoardJoystickEvent; + + public BalanceBoardEvent(int id, float topRight, float bottomRight, + float bottomLeft, float topLeft) { + super(id); + System.out.println(String.format("%f %f %f %f", topRight, bottomRight, bottomLeft, topLeft)); + /*balanceBoardJoystickEvent = new JoystickEvent(id, angle, + magnitude, max1, max2, min1, min2, center1, center2);*/ + } + + public boolean isThereBalanceBoardJoystickEvent() { + return balanceBoardJoystickEvent != null; + } + + public JoystickEvent getBalanceBoardJoystickEvent() { + return balanceBoardJoystickEvent; + } + + public String toString() { + String out = ""; + /* Status */ + out += "/*********** Balance Board EVENT : WIIMOTE ID :" + getWiimoteId() + + " ********/\n"; + out += balanceBoardJoystickEvent; + return out; + } + +} \ No newline at end of file diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ButtonsEvent.java new file mode 100644 index 0000000..2e12a22 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ButtonsEvent.java @@ -0,0 +1,128 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +import wiiusej.wiiusejevents.GenericEvent; + +/** + * Class which represents a buttons event. + * + * @author guiguito + */ +public abstract class ButtonsEvent extends GenericEvent { + + /* Buttons */ + private short buttonsJustPressed = 0; + private short buttonsJustReleased = 0; + private short buttonsHeld = 0; + + /** + * Constructor of the button Event. + * + * @param id + * id of the wiimote concerned. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just held. + */ + public ButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id); + setAllButtons(buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + + /** + * Set all buttons in one method. + * + * @param buttonsJustPressed + * @param buttonsJustReleased + * @param buttonsHeld + */ + private void setAllButtons(short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + this.buttonsJustPressed = buttonsJustPressed; + this.buttonsJustReleased = buttonsJustReleased; + this.buttonsHeld = buttonsHeld; + } + + /** + * Get the short storing the buttons just pressed + * + * @return the short storing the buttons just pressed + */ + public short getButtonsJustPressed() { + return buttonsJustPressed; + } + + /** + * Get the short storing the buttons just released + * + * @return the short storing the buttons just released + */ + public short getButtonsJustReleased() { + return buttonsJustReleased; + } + + /** + * get the short storing the buttons held + * + * @return the short storing the buttons held + */ + public short getButtonsHeld() { + return buttonsHeld; + } + + /** **************** BUTTONS Methods ***************** */ + /* generic button functions */ + + protected boolean buttonTest(int buttonBitsDefinition, int buttons) { + return (buttons & buttonBitsDefinition) == buttonBitsDefinition; + } + + protected boolean isButtonJustPressed(int buttonBitsDefinition) { + return buttonTest(buttonBitsDefinition, buttonsJustPressed) + && !isButtonHeld(buttonBitsDefinition); + } + + protected boolean isButtonJustReleased(int buttonBitsDefinition) { + return buttonTest(buttonBitsDefinition, buttonsJustReleased); + } + + protected boolean isButtonHeld(int buttonBitsDefinition) { + return buttonTest(buttonBitsDefinition, buttonsHeld); + } + + protected boolean isButtonPressed(int buttonBitsDefinition) { + return isButtonHeld(buttonBitsDefinition) + || isButtonJustPressed(buttonBitsDefinition); + } + + @Override + public String toString() { + String out = ""; + /* Display buttons */ + out += "/******** Buttons ********/\n"; + out += "--- Buttons just pressed : " + buttonsJustPressed + "\n"; + out += "--- Buttons just released : " + buttonsJustReleased + "\n"; + out += "--- Buttons held : " + buttonsHeld + "\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerButtonsEvent.java new file mode 100644 index 0000000..99c5bc9 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerButtonsEvent.java @@ -0,0 +1,329 @@ +/* This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * Class which represents a buttons event from a Classic controller. + * + * @author guiguito + */ +public class ClassicControllerButtonsEvent extends ButtonsEvent{ + + private static short CLASSIC_CTRL_BUTTON_UP = 0x0001; + private static short CLASSIC_CTRL_BUTTON_LEFT = 0x0002; + private static short CLASSIC_CTRL_BUTTON_ZR = 0x0004; + private static short CLASSIC_CTRL_BUTTON_X = 0x0008; + private static short CLASSIC_CTRL_BUTTON_A = 0x0010; + private static short CLASSIC_CTRL_BUTTON_Y = 0x0020; + private static short CLASSIC_CTRL_BUTTON_B = 0x0040; + private static short CLASSIC_CTRL_BUTTON_ZL = 0x0080; + private static short CLASSIC_CTRL_BUTTON_FULL_R = 0x0200; + private static short CLASSIC_CTRL_BUTTON_PLUS = 0x0400; + private static short CLASSIC_CTRL_BUTTON_HOME = 0x0800; + private static short CLASSIC_CTRL_BUTTON_MINUS = 0x1000; + private static short CLASSIC_CTRL_BUTTON_FULL_L = 0x2000; + private static short CLASSIC_CTRL_BUTTON_DOWN = 0x4000; + private static int CLASSIC_CTRL_BUTTON_RIGHT = 0x8000; + private static int CLASSIC_CTRL_BUTTON_ALL = 0xFEFF; + + /** + * Constructor of the classic controller buttons Event. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + */ + public ClassicControllerButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + + /* Button LEFT */ + + public boolean isButtonLeftJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_LEFT); + } + + public boolean isButtonLeftJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_LEFT); + } + + public boolean isButtonLeftHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_LEFT); + } + + public boolean isButtonLeftPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_LEFT); + } + + /* Button RIGHT */ + + public boolean isButtonRightJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_RIGHT); + } + + public boolean isButtonRightJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_RIGHT); + } + + public boolean isButtonRightHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_RIGHT); + } + + public boolean isButtonRightPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_RIGHT); + } + + /* Button UP */ + + public boolean isButtonUpJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_UP); + } + + public boolean isButtonUpJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_UP); + } + + public boolean isButtonUpHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_UP); + } + + public boolean isButtonUpPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_UP); + } + + /* Button DOWN */ + + public boolean isButtonDownJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_DOWN); + } + + public boolean isButtonDownJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_DOWN); + } + + public boolean isButtonDownHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_DOWN); + } + + public boolean isButtonDownPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_DOWN); + } + + /* Button A */ + + public boolean isButtonAJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_A); + } + + public boolean isButtonAJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_A); + } + + public boolean isButtonAHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_A); + } + + public boolean isButtonAPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_A); + } + + /* Button B */ + + public boolean isButtonBJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_B); + } + + public boolean isButtonBJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_B); + } + + public boolean isButtonBHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_B); + } + + public boolean isButtonBPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_B); + } + + /* Button X */ + + public boolean isButtonXJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_X); + } + + public boolean isButtonXJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_X); + } + + public boolean isButtonXHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_X); + } + + public boolean isButtonXPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_X); + } + + /* Button Y */ + + public boolean isButtonYJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_Y); + } + + public boolean isButtonYJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_Y); + } + + public boolean isButtonYHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_Y); + } + + public boolean isButtonYPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_Y); + } + + /* Button FullLeft */ + + public boolean isButtonFullLeftJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_FULL_L); + } + + public boolean isButtonFullLeftJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_FULL_L); + } + + public boolean isButtonFullLeftHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_FULL_L); + } + + public boolean isButtonFullLeftPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_FULL_L); + } + + /* Button FullRight */ + + public boolean isButtonFullRightJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_FULL_R); + } + + public boolean isButtonFullRightJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_FULL_R); + } + + public boolean isButtonFullRightHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_FULL_R); + } + + public boolean isButtonFullRightPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_FULL_R); + } + + /* Button Home */ + + public boolean isButtonHomeJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_HOME); + } + + public boolean isButtonHomeJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_HOME); + } + + public boolean isButtonHomeHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_HOME); + } + + public boolean isButtonHomePressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_HOME); + } + + /* Button Minus */ + + public boolean isButtonMinusJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_MINUS); + } + + public boolean isButtonMinusJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_MINUS); + } + + public boolean isButtonMinusHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_MINUS); + } + + public boolean isButtonMinusPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_MINUS); + } + + /* Button Plus */ + + public boolean isButtonPlusJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_PLUS); + } + + public boolean isButtonPlusJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_PLUS); + } + + public boolean isButtonPlusHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_PLUS); + } + + public boolean isButtonPlusPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_PLUS); + } + + /* Button ZL */ + + public boolean isButtonZLJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_ZL); + } + + public boolean isButtonZLJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_ZL); + } + + public boolean isButtonZLHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_ZL); + } + + public boolean isButtonZLPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_ZL); + } + + /* Button ZR */ + + public boolean isButtonZRJustPressed() { + return isButtonJustPressed(CLASSIC_CTRL_BUTTON_ZR); + } + + public boolean isButtonZRJustReleased() { + return isButtonJustReleased(CLASSIC_CTRL_BUTTON_ZR); + } + + public boolean isButtonZRHeld() { + return isButtonHeld(CLASSIC_CTRL_BUTTON_ZR); + } + + public boolean isButtonZRPressed() { + return isButtonPressed(CLASSIC_CTRL_BUTTON_ZR); + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerEvent.java new file mode 100644 index 0000000..214e030 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ClassicControllerEvent.java @@ -0,0 +1,177 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * This class represents the values from the classic controller and its events. + * + * @author guiguito + */ +public class ClassicControllerEvent extends ExpansionEvent { + + private float rightShoulder; + private float leftShoulder; + private ClassicControllerButtonsEvent buttonsEvent; + private JoystickEvent classicControllerRightJoystickEvent; + private JoystickEvent classicControllerLeftJoystickEvent; + + /** + * Constructor of ClassicControllerEvent. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param rightShoulder + * right shoulder button (range 0-1). + * @param leftShoulder + * left shoulder button (range 0-1). + * @param langle + * angle the left joystick is being held. + * @param lmagnitude + * magnitude of the left joystick (range 0-1). + * @param lmax1 + * maximum left joystick value 1. + * @param lmax2 + * maximum left joystick value 2. + * @param lmin1 + * minimum left joystick value 1. + * @param lmin2 + * minimum left joystick value 2. + * @param lcenter1 + * center left joystick value 1. + * @param lcenter2 + * center left joystick value 2. + * @param rangle + * angle the right joystick is being held. + * @param rmagnitude + * magnitude of the right joystick (range 0-1). + * @param rmax1 + * maximum right joystick value 1. + * @param rmax2 + * maximum right joystick value 2. + * @param rmin1 + * minimum right joystick value 1. + * @param rmin2 + * minimum right joystick value 2. + * @param rcenter1 + * center right joystick value 1. + * @param rcenter2 + * center right joystick value 2. + */ + public ClassicControllerEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, float rightShoulder, + float leftShoulder, float langle, float lmagnitude, short lmax1, + short lmax2, short lmin1, short lmin2, short lcenter1, + short lcenter2, float rangle, float rmagnitude, short rmax1, + short rmax2, short rmin1, short rmin2, short rcenter1, + short rcenter2) { + super(id); + this.leftShoulder = leftShoulder; + this.rightShoulder = rightShoulder; + buttonsEvent = new ClassicControllerButtonsEvent(id, + buttonsJustPressed, buttonsJustReleased, buttonsHeld); + classicControllerLeftJoystickEvent = new JoystickEvent(id, langle, + lmagnitude, lmax1, lmax2, lmin1, lmin2, lcenter1, lcenter2); + classicControllerRightJoystickEvent = new JoystickEvent(id, rangle, + rmagnitude, rmax1, rmax2, rmin1, rmin2, rcenter1, rcenter2); + } + + /** + * Tell if there is a classic controller left joystick event. + * + * @return TRUE if there is a classic controller left joystick event, false + * otherwise. + */ + public boolean isThereClassicControllerLeftJoystickEvent() { + return classicControllerLeftJoystickEvent != null; + } + + /** + * Tell if there is a classic controller right joystick event. + * + * @return TRUE if there is a classic controller right joystick event, false + * otherwise. + */ + public boolean isThereClassicControllerRightJoystickEvent() { + return classicControllerRightJoystickEvent != null; + } + + /** + * Get the right shoulder button(range 0-1). + * + * @return value of the rightShoulder button. + */ + public float getRightShoulder() { + return rightShoulder; + } + + /** + * Get the left shoulder button(range 0-1). + * + * @return value of the leftShoulder button. + */ + public float getLeftShoulder() { + return leftShoulder; + } + + /** + * Get buttons event for the classic controller. + * + * @return the classic controller buttons event if there is one or null. + */ + public ClassicControllerButtonsEvent getButtonsEvent() { + return buttonsEvent; + } + + /** + * Get event from the right joystick of the classic controller. + * + * @return the classic controller right Joystick Event if there is one or null. + */ + public JoystickEvent getClassicControllerRightJoystickEvent() { + return classicControllerRightJoystickEvent; + } + + /** + * Get event from the left joystick of the classic controller. + * + * @return the classic controller left Joystick Event if there is one or null. + */ + public JoystickEvent getClassicControllerLeftJoystickEvent() { + return classicControllerLeftJoystickEvent; + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** Classic Controller EVENT : WIIMOTE ID :" + + getWiimoteId() + " ********/\n"; + out += buttonsEvent; + out += "Left shoulder : " + leftShoulder + "\n"; + out += "Right shoulder : " + rightShoulder + "\n"; + out += classicControllerLeftJoystickEvent; + out += classicControllerRightJoystickEvent; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ExpansionEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ExpansionEvent.java new file mode 100644 index 0000000..0b71a4c --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/ExpansionEvent.java @@ -0,0 +1,40 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +import wiiusej.wiiusejevents.GenericEvent; + +/** + * Mother Class of all expansions event. + * + * @author guiguito + */ +public abstract class ExpansionEvent extends GenericEvent { + + /** + * Constructor of an ExpansionEvent. + * + * @param id + * id of the wiimote to which the expansion is connected. + */ + public ExpansionEvent(int id) { + super(id); + } + + public abstract String toString(); + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroButtonsEvent.java new file mode 100644 index 0000000..92d139e --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroButtonsEvent.java @@ -0,0 +1,214 @@ +/* This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * Class which represents a buttons event from a Guitar Hero controller. + * + * @author guiguito + */ +public class GuitarHeroButtonsEvent extends ButtonsEvent { + + private static short GUITAR_HERO_3_BUTTON_STRUM_UP = 0x0001; + private static short GUITAR_HERO_3_BUTTON_YELLOW = 0x0008; + private static short GUITAR_HERO_3_BUTTON_GREEN = 0x0010; + private static short GUITAR_HERO_3_BUTTON_BLUE = 0x0020; + private static short GUITAR_HERO_3_BUTTON_RED = 0x0040; + private static short GUITAR_HERO_3_BUTTON_ORANGE = 0x0080; + private static short GUITAR_HERO_3_BUTTON_PLUS = 0x0400; + private static short GUITAR_HERO_3_BUTTON_MINUS = 0x1000; + private static short GUITAR_HERO_3_BUTTON_STRUM_DOWN = 0x4000; + private static int GUITAR_HERO_3_BUTTON_ALL = 0xFEFF; + + /** + * Constructor of the guitar hero buttons Event. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + */ + public GuitarHeroButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + + /* Button Strum Up */ + + public boolean isButtonStrumUpJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_STRUM_UP); + } + + public boolean isButtonStrumUpJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_STRUM_UP); + } + + public boolean isButtonStrumUpeHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_STRUM_UP); + } + + public boolean isButtonStrumUpPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_STRUM_UP); + } + + /* Button Strum Down */ + + public boolean isButtonStrumDownJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_STRUM_DOWN); + } + + public boolean isButtonStrumDownJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_STRUM_DOWN); + } + + public boolean isButtonStrumDowneHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_STRUM_DOWN); + } + + public boolean isButtonStrumDownPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_STRUM_DOWN); + } + + /* Button blue */ + + public boolean isButtonBlueJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_BLUE); + } + + public boolean isButtonBlueJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_BLUE); + } + + public boolean isButtonBlueHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_BLUE); + } + + public boolean isButtonBluePressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_BLUE); + } + + /* Button Green */ + + public boolean isButtonGreenJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_GREEN); + } + + public boolean isButtonGreenJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_GREEN); + } + + public boolean isButtonGreenHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_GREEN); + } + + public boolean isButtonGreenPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_GREEN); + } + + /* Button Minus */ + + public boolean isButtonMinusJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_MINUS); + } + + public boolean isButtonMinusJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_MINUS); + } + + public boolean isButtonMinusHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_MINUS); + } + + public boolean isButtonMinusPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_MINUS); + } + + /* Button Orange */ + + public boolean isButtonOrangeJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_ORANGE); + } + + public boolean isButtonOrangeJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_ORANGE); + } + + public boolean isButtonOrangeHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_ORANGE); + } + + public boolean isButtonOrangePressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_ORANGE); + } + + /* Button Plus */ + + public boolean isButtonPlusJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_PLUS); + } + + public boolean isButtonPlusJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_PLUS); + } + + public boolean isButtonPlusHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_PLUS); + } + + public boolean isButtonPlusPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_PLUS); + } + + /* Button Red */ + + public boolean isButtonRedJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_RED); + } + + public boolean isButtonRedJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_RED); + } + + public boolean isButtonRedHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_RED); + } + + public boolean isButtonRedPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_RED); + } + + /* Button Yellow */ + + public boolean isButtonYellowJustPressed() { + return isButtonJustPressed(GUITAR_HERO_3_BUTTON_YELLOW); + } + + public boolean isButtonYellowJustReleased() { + return isButtonJustReleased(GUITAR_HERO_3_BUTTON_YELLOW); + } + + public boolean isButtonYellowHeld() { + return isButtonHeld(GUITAR_HERO_3_BUTTON_YELLOW); + } + + public boolean isButtonYellowPressed() { + return isButtonPressed(GUITAR_HERO_3_BUTTON_YELLOW); + } +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroEvent.java new file mode 100644 index 0000000..6fb9e8c --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/GuitarHeroEvent.java @@ -0,0 +1,119 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * This class represents the values from the GuitarHero and its events. + * + * @author guiguito + */ +public class GuitarHeroEvent extends ExpansionEvent{ + + private float whammyBar; + private GuitarHeroButtonsEvent buttonsEvent; + private JoystickEvent guitarHeroJoystickEvent; + + /** + * Constructor of GuitarHeroEvent. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param whammyBar + * whammy bar (range 0-1). + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public GuitarHeroEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, float whammyBar, + float angle, float magnitude, short max1, + short max2, short min1, short min2, short center1, + short center2) { + super(id); + this.whammyBar = whammyBar; + buttonsEvent = new GuitarHeroButtonsEvent(id, + buttonsJustPressed, buttonsJustReleased, buttonsHeld); + guitarHeroJoystickEvent = new JoystickEvent(id, angle, + magnitude, max1, max2, min1, min2, center1, center2); + + } + + /** + * Tell if there is a Guitar Hero joystick event. + * + * @return TRUE if there is a Guitar Hero joystick event, false otherwise. + */ + public boolean isThereGuitarHeroJoystickEvent() { + return guitarHeroJoystickEvent != null; + } + + /** + * Whammy bar (range 0-1). + * @return the whammyBar value. + */ + public float getWhammyBar() { + return whammyBar; + } + + /** + * Get buttons event for the guitar hero controller. + * @return the guitar hero controller buttons event if there is one or null. + */ + public GuitarHeroButtonsEvent getButtonsEvent() { + return buttonsEvent; + } + + /** + * Get event from the joystick of the guitar hero controller. + * @return the guitar hero controller joystick Event if there is one or null. + */ + public JoystickEvent getGuitarHeroJoystickEvent() { + return guitarHeroJoystickEvent; + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** Guitar Hero 3 EVENT : WIIMOTE ID :" + getWiimoteId() + + " ********/\n"; + out += buttonsEvent; + out += "Whammy Bar : "+whammyBar+"\n"; + out += guitarHeroJoystickEvent; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/IREvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/IREvent.java new file mode 100644 index 0000000..74d4f2c --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/IREvent.java @@ -0,0 +1,319 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +import wiiusej.values.IRSource; +import wiiusej.wiiusejevents.GenericEvent; + +/** + * Class which represents an IR event. + * + * @author guiguito + */ +public class IREvent extends GenericEvent { + + /* IR Tracking */ + private IRSource[] IRPoints; + private short indexPoints = 0; + private int x; + private int y; + private float z;// distance from the sensor bar + private int ax; + private int ay; + private int xVRes; + private int yVRes; + private int xOffset; + private int yOffset; + private short sensorBarPostion; + private short screenAsPectRatio; + private short irSensitivity; + private float distance; + + static private short WIIUSE_IR_ABOVE = 0; + static private short WIIUSE_IR_BELOW = 1; + static private short WIIUSE_SCREEN_RATIO_4_3 = 0; + static private short WIIUSE_SCREEN_RATIO_16_9 = 1; + + private static short NB_POINTS = 4;// number of points IR can track + + /** + * Constructor of IREvent with full infos. + * + * @param id + * d of the wiimote concerned. + * @param x + * calculated X coordinate. + * @param y + * calculated Y coordinate. + * @param z + * calculated distance. + * @param ax + * absolute X coordinate. + * @param ay + * absolute Y coordinate + * @param xVRes + * IR virtual screen x resolution. + * @param yVRes + * IR virtual screen y resolution. + * @param xOffset + * IR X correction offset. + * @param yOffset + * IR Y correction offset. + * @param sensorBarPostion + * aspect ratio of the screen. + * @param screenAsPectRatio + * IR sensor bar position. + * @param irSensitivity + * Sensitivity of the infrared camera. + * @param distance + * Pixel Distance between first two dots + */ + public IREvent(int id, int x, int y, float z, int ax, int ay, int xVRes, + int yVRes, int xOffset, int yOffset, short sensorBarPostion, + short screenAsPectRatio, short irSensitivity, float distance) { + super(id); + this.x = x; + this.y = y; + this.z = z; + this.ax = ax; + this.ay = ay; + this.xVRes = xVRes; + this.yVRes = yVRes; + this.xOffset = xOffset; + this.yOffset = yOffset; + this.sensorBarPostion = sensorBarPostion; + this.screenAsPectRatio = screenAsPectRatio; + this.irSensitivity = irSensitivity; + this.distance = distance; + IRPoints = new IRSource[NB_POINTS]; + } + + /** + * Get list of IR points. + * + * @return the list of 2D points + */ + public IRSource[] getIRPoints() { + IRSource[] ir = new IRSource[indexPoints]; + System.arraycopy(IRPoints, 0, ir, 0, indexPoints); + return ir; + } + + /** + * Add IR Point in the list (Max 4 points) + * + * @param x + * x value + * @param y + * y value + * @param rx + * raw X coordinate (0-1023). + * @param ry + * raw Y coordinate (0-1023). + * @param size + * size of the IR dot (0-15). + */ + public void addIRpoint(int x, int y, short rx, short ry, short size) { + IRPoints[indexPoints] = new IRSource(x, y, rx, ry, size); + indexPoints++; + return; + } + + /** + * Return calculated X coordinate. + * + * @return the x + */ + public int getX() { + return x; + } + + /** + * Return calculated Y coordinate. + * + * @return the y + */ + public int getY() { + return y; + } + + /** + * Return calculated distance. + * + * @return the z + */ + public float getZ() { + return z; + } + + /** + * Return absolute X coordinate. + * + * @return the ax + */ + public int getAx() { + return ax; + } + + /** + * Return absolute Y coordinate. + * + * @return the ay + */ + public int getAy() { + return ay; + } + + /** + * Return IR virtual screen x resolution. + * + * @return the xVRes + */ + public int getXVRes() { + return xVRes; + } + + /** + * Return IR virtual screen y resolution. + * + * @return the yVRes + */ + public int getYVRes() { + return yVRes; + } + + /** + * Return IR X correction offset. + * + * @return the xOffset + */ + public int getXOffset() { + return xOffset; + } + + /** + * Return IR Y correction offset. + * + * @return the yOffset + */ + public int getYOffset() { + return yOffset; + } + + /** + * Return true if the sensor bar is above. + * + * @return true if the sensor bar is above. + */ + public boolean isSensorBarAbove() { + return sensorBarPostion == WIIUSE_IR_ABOVE; + } + + /** + * Return true if the sensor bar is below. + * + * @return true if the sensor bar is below. + */ + public boolean isSensorBarBelow() { + return sensorBarPostion == WIIUSE_IR_BELOW; + } + + /** + * Return true if screen aspect ratio set is 4/3. + * + * @return true if screen aspect ratio set is 4/3. + */ + public boolean isScreenAspectRatio43() { + return screenAsPectRatio == WIIUSE_SCREEN_RATIO_4_3; + } + + /** + * Return true if screen aspect ratio set is 16/9. + * + * @return true if screen aspect ratio set is 16/9. + */ + public boolean isScreenAspectRatio169() { + return screenAsPectRatio == WIIUSE_SCREEN_RATIO_16_9; + } + + /** + * Return aspect ratio of the screen. + * + * @return the screenAsPectRatio + */ + public short getScreenAsPectRatio() { + return screenAsPectRatio; + } + + /** + * The sensitivity of the IR camera can be turned up or down depending on + * your needs. Like the Wii, wiiusej and wiiuse can set the camera + * sensitivity to a degree between 1 (lowest) and 5 (highest). The default + * is 3. + * + * @return the irSensitivity + */ + public short getIrSensitivity() { + return irSensitivity; + } + + /** + * Pixel distance between first 2 dots. + * + * @return the distance between first 2 dots. + */ + public float getDistance() { + return distance; + } + + @Override + public String toString() { + String out = ""; + /* Display IR Tracking */ + out += "/******** IR Tracking ********/\n"; + out += "--- Active : true\n"; + out += "--- calculated X coordinate : " + x + "\n"; + out += "--- calculated Y coordinate : " + y + "\n"; + out += "--- calculated Z coordinate : " + z + "\n"; + out += "--- calculated distance : " + distance + "\n"; + out += "--- absolute X coordinate : " + ax + "\n"; + out += "--- absolute Y coordinate : " + ay + "\n"; + out += "--- IR virtual screen x resolution : " + xVRes + "\n"; + out += "--- IR virtual screen y resolution : " + yVRes + "\n"; + out += "--- IR X correction offset : " + xOffset + "\n"; + out += "--- IR Y correction offset : " + yOffset + "\n"; + out += "--- IR Sensitivity (between 1-5) : " + irSensitivity + "\n"; + if (isScreenAspectRatio43()) { + out += "--- aspect ratio of the screen : 4/3\n"; + } else if (isScreenAspectRatio169()) { + out += "--- aspect ratio of the screen : 16/9\n"; + } + if (isSensorBarAbove()) { + out += "--- IR sensor bar position. : Above\n"; + } else if (isSensorBarBelow()) { + out += "--- IR sensor bar position. : Below\n"; + } + out += "--- Seen points\n"; + for (int i = 0; i < IRPoints.length; i++) { + if (IRPoints[i] != null) { + out += IRPoints[i].toString(); + } + } + out += "\n"; + return out; + } +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/JoystickEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/JoystickEvent.java new file mode 100644 index 0000000..cab6b1d --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/JoystickEvent.java @@ -0,0 +1,135 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +import wiiusej.wiiusejevents.GenericEvent; + +/** + * Class that stores values on a joystick Event. + * + * @author guiguito + */ +public class JoystickEvent extends GenericEvent { + + private float angle; + private float magnitude; + private short[] max; + private short[] min; + private short[] center; + + /** + * Constructor of a JoystickEvent. + * + * @param id + * id of the wiimote connected. + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public JoystickEvent(int id, float angle, float magnitude, short max1, + short max2, short min1, short min2, short center1, short center2) { + super(id); + this.angle = angle; + this.magnitude = magnitude; + max = new short[2]; + max[0] = max1; + max[1] = max2; + min = new short[2]; + min[0] = min1; + min[1] = min2; + center = new short[2]; + center[0] = center1; + center[1] = center2; + } + + /** + * Get angle the joystick is being held. + * + * @return the angle angle the joystick. + */ + public float getAngle() { + return angle; + } + + /** + * Get magnitude of the joystick (range 0-1). + * + * @return the magnitude magnitude of the joystick. + */ + public float getMagnitude() { + return magnitude; + } + + /** + * Maximum joystick values. + * + * @return the max + */ + public short[] getMax() { + return max; + } + + /** + * Minimum joystick values. + * + * @return the min + */ + public short[] getMin() { + return min; + } + + /** + * Center joystick values. + * + * @return the center + */ + public short[] getCenter() { + return center; + } + + /* + * (non-Javadoc) + * + * @see wiiusej.wiiusejevents.GenericEvent#toString() + */ + @Override + public String toString() { + String out = ""; + /* Display IR Tracking */ + out += "/******** Joystick ********/\n"; + out += "--- angle : " + angle + "\n"; + out += "--- magnitude : " + magnitude + "\n"; + out += "--- maximum values : " + max[0] + "," + max[1] + "\n"; + out += "--- minimum values : " + min[0] + "," + min[1] + "\n"; + out += "--- center values : " + center[0] + "," + center[1] + "\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/MotionSensingEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/MotionSensingEvent.java new file mode 100644 index 0000000..eb4a642 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/MotionSensingEvent.java @@ -0,0 +1,204 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +import wiiusej.values.GForce; +import wiiusej.values.Orientation; +import wiiusej.values.RawAcceleration; +import wiiusej.wiiusejevents.GenericEvent; + +/** + * Class which represents a motion sensing event. + * + * @author guiguito + */ +public class MotionSensingEvent extends GenericEvent { + protected static final long serialVersionUID = 1L; + + /* Motion Sensing */ + private Orientation orientation; + private GForce gforce; + private RawAcceleration acceleration; + + private float orientationThreshold = 0; + private int accelerationThreshold = 0; + private float alphaSmoothing = 0; + private boolean isSmoothingActive = false; + + /** + * Constructor for a Motion Sensing Event. + * + * @param id + * id of the wiimote concerned. + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + */ + public MotionSensingEvent(int id, float orientationThreshold, + int accelerationThreshold, boolean smoothingState, + float alphaSmooth, float r, float p, float ya, float ar, float ap, + float x, float y, float z, short xx, short yy, short zz) { + super(id); + this.orientationThreshold = orientationThreshold; + this.accelerationThreshold = accelerationThreshold; + this.isSmoothingActive = smoothingState; + this.alphaSmoothing = alphaSmooth; + setOrientationAndGforce(r, p, ya, ar, ap, x, y, z, xx, yy, zz); + } + + /** + * Set orientation, gravity force and raw acceleration. + * + * @param r + * roll + * @param p + * pitch + * @param ya + * yaw + * @param ar + * absolute roll + * @param ap + * absolute pitch + * @param x + * gravity force on x axis + * @param y + * gravity force on y axis + * @param z + * gravity force on z axis + * @param xx + * raw acceleration on x axis + * @param yy + * raw acceleration on y axis + * @param zz + * raw acceleration on z axis + */ + private void setOrientationAndGforce(float r, float p, float ya, float ar, + float ap, float x, float y, float z, short xx, short yy, short zz) { + this.orientation = new Orientation(r, p, ya, ar, ap); + this.gforce = new GForce(x, y, z); + this.acceleration = new RawAcceleration(xx, yy, zz); + } + + /** + * @return the orientation + */ + public Orientation getOrientation() { + return orientation; + } + + /** + * Get the gravity force. + * + * @return the gforce + */ + public GForce getGforce() { + return gforce; + } + + /** + * Get the raw acceleration. + * + * @return the raw acceleration + */ + public RawAcceleration getRawAcceleration() { + return acceleration; + } + + /** + * Get orientation threshold. + * + * @return the orientationThreshold + */ + public float getOrientationThreshold() { + return orientationThreshold; + } + + /** + * Get acceleration threshold. + * + * @return the accelerationThreshold + */ + public int getAccelerationThreshold() { + return accelerationThreshold; + } + + /** + * Get alpha smoothing. + * + * @return the alphaSmoothing + */ + public float getAlphaSmoothing() { + return alphaSmoothing; + } + + /** + * Tell if the option SMOOTHING is activated. + * + * @return the isSmoothingActive + */ + public boolean isSmoothingActive() { + return isSmoothingActive; + } + + @Override + public String toString() { + String out = ""; + /* Motion sensing */ + out += "/******** Motion sensing ********/\n"; + out += "--- Motion sensing : true \n"; + out += "--- Orientation threshold value ? : " + orientationThreshold + + "\n"; + out += "--- Acceleration threshold value ? : " + accelerationThreshold + + "\n"; + out += "--- Alpha smoothing threshold value ? : " + alphaSmoothing + + "\n"; + out += "--- Smoothing ? : " + isSmoothingActive + "\n"; + out += "--- " + orientation + "\n"; + out += "--- " + gforce + "\n"; + out += "--- " + acceleration + "\n"; + return out; + } +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukButtonsEvent.java new file mode 100644 index 0000000..4cab0ae --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukButtonsEvent.java @@ -0,0 +1,89 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * Class which represents a buttons event from a Nunchuk. + * + * @author guiguito + */ +public class NunchukButtonsEvent extends ButtonsEvent { + + private static short NUNCHUK_BUTTON_Z = 0x01; + private static short NUNCHUK_BUTTON_C = 0x02; + private static short NUNCHUK_BUTTON_ALL = 0x03; + + /** + * Constructor of the nunchuk buttons Event. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + */ + public NunchukButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + + /* Button Z */ + + public boolean isButtonZJustPressed() { + return isButtonJustPressed(NUNCHUK_BUTTON_Z); + } + + public boolean isButtonZJustReleased() { + return isButtonJustReleased(NUNCHUK_BUTTON_Z); + } + + public boolean isButtonZeHeld() { + return isButtonHeld(NUNCHUK_BUTTON_Z); + } + + public boolean isButtonZPressed() { + return isButtonPressed(NUNCHUK_BUTTON_Z); + } + + /* Button Z */ + + public boolean isButtonCJustPressed() { + return isButtonJustPressed(NUNCHUK_BUTTON_C); + } + + public boolean isButtonCJustReleased() { + return isButtonJustReleased(NUNCHUK_BUTTON_C); + } + + public boolean isButtonCHeld() { + return isButtonHeld(NUNCHUK_BUTTON_C); + } + + public boolean isButtonCPressed() { + return isButtonPressed(NUNCHUK_BUTTON_C); + } + + @Override + public String toString() { + return "/******** Buttons for Nunchuk Event ********/\n" + + super.toString(); + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukEvent.java new file mode 100644 index 0000000..12a8275 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/NunchukEvent.java @@ -0,0 +1,169 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * This class represents the values from the joystick and its events. + * + * @author guiguito + */ +public class NunchukEvent extends ExpansionEvent { + + private NunchukButtonsEvent buttonsEvent; + private MotionSensingEvent nunchukMotionSensingEvent; + private JoystickEvent nunchukJoystickEvent; + + /** + * Constructor of NunchukEvent. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public NunchukEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, + float orientationThreshold, int accelerationThreshold, + boolean smoothingState, float alphaSmooth, float r, float p, + float ya, float ar, float ap, float x, float y, float z, short xx, + short yy, short zz, float angle, float magnitude, short max1, + short max2, short min1, short min2, short center1, short center2) { + super(id); + buttonsEvent = new NunchukButtonsEvent(id, buttonsJustPressed, + buttonsJustReleased, buttonsHeld); + nunchukMotionSensingEvent = new MotionSensingEvent(id, + orientationThreshold, accelerationThreshold, smoothingState, + alphaSmooth, r, p, ya, ar, ap, x, y, z, xx, yy, zz); + nunchukJoystickEvent = new JoystickEvent(id, angle, magnitude, max1, + max2, min1, min2, center1, center2); + } + + /** + * Tell if there is a nunchuk motion sensing Event. + * + * @return TRUE if there is a nunchuk motion sensing event, false otherwise. + */ + public boolean isThereMotionSensingEvent() { + return nunchukMotionSensingEvent != null; + } + + /** + * Tell if there is a nunchuk joystick event. + * + * @return TRUE if there is a nunchuk joystick event, false otherwise. + */ + public boolean isThereNunchukJoystickEvent() { + return nunchukJoystickEvent != null; + } + + /** + * Get nunchuk buttons event. + * + * @return the nunchuk buttons event if there is one or null. + */ + public NunchukButtonsEvent getButtonsEvent() { + return buttonsEvent; + } + + /** + * Get the nunchuk motion sensing event. + * + * @return the nunchuk motion sensing event if there is one or null. + */ + public MotionSensingEvent getNunchukMotionSensingEvent() { + return nunchukMotionSensingEvent; + } + + /** + * Get the nunchuk joystick event. + * + * @return the nunchuk Joystick Event if there is one or null. + */ + public JoystickEvent getNunchukJoystickEvent() { + return nunchukJoystickEvent; + } + + /* + * (non-Javadoc) + * + * @see wiiusej.wiiusejevents.GenericEvent#toString() + */ + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** Nunchuk EVENT : WIIMOTE ID :" + getWiimoteId() + + " ********/\n"; + out += buttonsEvent; + out += nunchukJoystickEvent; + out += nunchukMotionSensingEvent; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/physicalevents/WiimoteButtonsEvent.java b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/WiimoteButtonsEvent.java new file mode 100644 index 0000000..9af3249 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/physicalevents/WiimoteButtonsEvent.java @@ -0,0 +1,267 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.physicalevents; + +/** + * Class which represents a buttons event for a generic event. It means buttons + * from a wiimote. + * + * @author guiguito + */ +public class WiimoteButtonsEvent extends ButtonsEvent { + + /* Buttons MACRO */ + private static short WIIMOTE_BUTTON_TWO = 0x0001; + private static short WIIMOTE_BUTTON_ONE = 0x0002; + private static short WIIMOTE_BUTTON_B = 0x0004; + private static short WIIMOTE_BUTTON_A = 0x0008; + private static short WIIMOTE_BUTTON_MINUS = 0x0010; + private static short WIIMOTE_BUTTON_ZACCEL_BIT6 = 0x0020; + private static short WIIMOTE_BUTTON_ZACCEL_BIT7 = 0x0040; + private static short WIIMOTE_BUTTON_HOME = 0x0080; + private static short WIIMOTE_BUTTON_LEFT = 0x0100; + private static short WIIMOTE_BUTTON_RIGHT = 0x0200; + private static short WIIMOTE_BUTTON_DOWN = 0x0400; + private static short WIIMOTE_BUTTON_UP = 0x0800; + private static short WIIMOTE_BUTTON_PLUS = 0x1000; + private static short WIIMOTE_BUTTON_ZACCEL_BIT4 = 0x2000; + private static short WIIMOTE_BUTTON_ZACCEL_BIT5 = 0x4000; + private static int WIIMOTE_BUTTON_UNKNOWN = 0x8000; + private static short WIIMOTE_BUTTON_ALL = 0x1F9F; + + /** + * Constructor of the wiimote button Event. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons held. + */ + public WiimoteButtonsEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld); + } + + /* Button ONE */ + + public boolean isButtonOneJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_ONE); + } + + public boolean isButtonOneJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_ONE); + } + + public boolean isButtonOneHeld() { + return isButtonHeld(WIIMOTE_BUTTON_ONE); + } + + public boolean isButtonOnePressed() { + return isButtonPressed(WIIMOTE_BUTTON_ONE); + } + + /* Button TWO */ + + public boolean isButtonTwoJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_TWO); + } + + public boolean isButtonTwoJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_TWO); + } + + public boolean isButtonTwoHeld() { + return isButtonHeld(WIIMOTE_BUTTON_TWO); + } + + public boolean isButtonTwoPressed() { + return isButtonPressed(WIIMOTE_BUTTON_TWO); + } + + /* Button A */ + + public boolean isButtonAJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_A); + } + + public boolean isButtonAJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_A); + } + + public boolean isButtonAHeld() { + return isButtonHeld(WIIMOTE_BUTTON_A); + } + + public boolean isButtonAPressed() { + return isButtonPressed(WIIMOTE_BUTTON_A); + } + + /* Button B */ + + public boolean isButtonBJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_B); + } + + public boolean isButtonBJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_B); + } + + public boolean isButtonBHeld() { + return isButtonHeld(WIIMOTE_BUTTON_B); + } + + public boolean isButtonBPressed() { + return isButtonPressed(WIIMOTE_BUTTON_B); + } + + /* Button LEFT */ + + public boolean isButtonLeftJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_LEFT); + } + + public boolean isButtonLeftJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_LEFT); + } + + public boolean isButtonLeftHeld() { + return isButtonHeld(WIIMOTE_BUTTON_LEFT); + } + + public boolean isButtonLeftPressed() { + return isButtonPressed(WIIMOTE_BUTTON_LEFT); + } + + /* Button RIGHT */ + + public boolean isButtonRightJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_RIGHT); + } + + public boolean isButtonRightJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_RIGHT); + } + + public boolean isButtonRightHeld() { + return isButtonHeld(WIIMOTE_BUTTON_RIGHT); + } + + public boolean isButtonRightPressed() { + return isButtonPressed(WIIMOTE_BUTTON_RIGHT); + } + + /* Button UP */ + + public boolean isButtonUpJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_UP); + } + + public boolean isButtonUpJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_UP); + } + + public boolean isButtonUpHeld() { + return isButtonHeld(WIIMOTE_BUTTON_UP); + } + + public boolean isButtonUpPressed() { + return isButtonPressed(WIIMOTE_BUTTON_UP); + } + + /* Button DOWN */ + + public boolean isButtonDownJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_DOWN); + } + + public boolean isButtonDownJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_DOWN); + } + + public boolean isButtonDownHeld() { + return isButtonHeld(WIIMOTE_BUTTON_DOWN); + } + + public boolean isButtonDownPressed() { + return isButtonPressed(WIIMOTE_BUTTON_DOWN); + } + + /* Button - */ + + public boolean isButtonMinusJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_MINUS); + } + + public boolean isButtonMinusJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_MINUS); + } + + public boolean isButtonMinusHeld() { + return isButtonHeld(WIIMOTE_BUTTON_MINUS); + } + + public boolean isButtonMinusPressed() { + return isButtonPressed(WIIMOTE_BUTTON_MINUS); + } + + /* Button + */ + + public boolean isButtonPlusJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_PLUS); + } + + public boolean isButtonPlusJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_PLUS); + } + + public boolean isButtonPlusHeld() { + return isButtonHeld(WIIMOTE_BUTTON_PLUS); + } + + public boolean isButtonPlusPressed() { + return isButtonPressed(WIIMOTE_BUTTON_PLUS); + } + + /* Button HOME */ + + public boolean isButtonHomeJustPressed() { + return isButtonJustPressed(WIIMOTE_BUTTON_HOME); + } + + public boolean isButtonHomeJustReleased() { + return isButtonJustReleased(WIIMOTE_BUTTON_HOME); + } + + public boolean isButtonHomeHeld() { + return isButtonHeld(WIIMOTE_BUTTON_HOME); + } + + public boolean isButtonHomePressed() { + return isButtonPressed(WIIMOTE_BUTTON_HOME); + } + + @Override + public String toString() { + return "/******** Buttons for Wiimote generic Event ********/\n" + + super.toString(); + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/utils/EventsGatherer.java b/java/src/main/java/wiiusej/wiiusejevents/utils/EventsGatherer.java new file mode 100644 index 0000000..75a9ac7 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/utils/EventsGatherer.java @@ -0,0 +1,529 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.utils; + +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent; +import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent; +import wiiusej.wiiusejevents.wiiuseapievents.WiimoteEvent; + +/** + * This class is used to gather events during a call to the Wiiuse API. + * + * @author guiguito + */ +public class EventsGatherer { + + private WiiUseApiEvent[] events; + private int index = 0; + private WiimoteEvent genericEvent = null; + + /** + * Create EventsGatherer. + * + * @param nbWiimotes + * nb wiimotes (nb a of events possible in a call to Wiiuse API). + */ + public EventsGatherer(int nbWiimotes) { + events = new WiiUseApiEvent[nbWiimotes]; + } + + /** + * Add an event to the array. + * + * @param e + * the event to add. + */ + private void addEvent(WiiUseApiEvent e) { + events[index] = e; + index++; + } + + /** + * Prepare a wiimote event to add. + * + * @param id + * id of the wiimote. + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons held. + */ + public void prepareWiiMoteEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + genericEvent = new WiimoteEvent(id, buttonsJustPressed, + buttonsJustReleased, buttonsHeld); + } + + /** + * Prepare an IR event to populate. + * + * @param x + * calculated X coordinate. + * @param y + * calculated Y coordinate. + * @param z + * calculated distance. + * @param ax + * absolute X coordinate. + * @param ay + * absolute Y coordinate. + * @param xVRes + * IR virtual screen x resolution. + * @param yVRes + * IR virtual screen y resolution. + * @param xOffset + * IR X correction offset. + * @param yOffset + * IR Y correction offset. + * @param sensorBarPostion + * aspect ratio of the screen. + * @param screenAsPectRatio + * IR sensor bar position. + * @param irSensitivity + * Sensitivity of the infrared camera. + * @param distance + * Pixel Distance between first two dots. + */ + public void prepareIRevent(int x, int y, float z, int ax, int ay, + int xVRes, int yVRes, int xOffset, int yOffset, + short sensorBarPostion, short screenAsPectRatio, + short irSensitivity, float distance) { + genericEvent.prepareIRevent(x, y, z, ax, ay, xVRes, yVRes, xOffset, + yOffset, sensorBarPostion, screenAsPectRatio, irSensitivity, + distance); + + } + + /** + * Add an IR point to the WiiMoteEvent prepared. + * + * @param x + * x coordinates. + * @param y + * y coordinates. + * @param rx + * raw X coordinate (0-1023). + * @param ry + * raw Y coordinate (0-1023). + * @param size + * size of the IR dot (0-15). + */ + public void addIRPointToPreparedWiiMoteEvent(int x, int y, short rx, + short ry, short size) { + if (genericEvent != null) { + genericEvent.addIRpoint(x, y, rx, ry, size); + } + } + + /** + * Set orientation and gravity force of the prepared event. + * + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + */ + public void addMotionSensingValues(float orientationThreshold, + int accelerationThreshold, boolean smoothingState, + float alphaSmooth, float r, float p, float ya, float ar, float ap, + float x, float y, float z, short xx, short yy, short zz) { + if (genericEvent != null) { + genericEvent.setMotionSensingEvent(orientationThreshold, + accelerationThreshold, smoothingState, alphaSmooth, r, p, + ya, ar, ap, x, y, z, xx, yy, zz); + } + } + + /** + * Set a NunchukEvent to the prepared WiimoteEvent. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public void addNunchunkEventToPreparedWiimoteEvent( + short buttonsJustPressed, short buttonsJustReleased, + short buttonsHeld, float orientationThreshold, + int accelerationThreshold, boolean smoothingState, + float alphaSmooth, float r, float p, float ya, float ar, float ap, + float x, float y, float z, short xx, short yy, short zz, + float angle, float magnitude, short max1, short max2, short min1, + short min2, short center1, short center2) { + if (genericEvent != null) { + genericEvent.setNunchukEvent(buttonsJustPressed, + buttonsJustReleased, buttonsHeld, orientationThreshold, + accelerationThreshold, smoothingState, alphaSmooth, r, p, + ya, ar, ap, x, y, z, xx, yy, zz, angle, magnitude, max1, + max2, min1, min2, center1, center2); + } + } + + /** + * Set a GuitarHeroEvent to the prepared WiimoteEvent. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param whammyBar + * whammy bar (range 0-1). + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public void addGuitarHeroEventToPreparedWiimoteEvent( + short buttonsJustPressed, short buttonsJustReleased, + short buttonsHeld, float whammyBar, float angle, float magnitude, + short max1, short max2, short min1, short min2, short center1, + short center2) { + if (genericEvent != null) { + genericEvent.setGuitarHeroEvent(buttonsJustPressed, + buttonsJustReleased, buttonsHeld, whammyBar, angle, + magnitude, max1, max2, min1, min2, center1, center2); + } + } + + /** + * Set a ClassicControllerEvent to the prepared WiimoteEvent. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param rightShoulder + * right shoulder button (range 0-1). + * @param leftShoulder + * left shoulder button (range 0-1). + * @param langle + * angle the left joystick is being held. + * @param lmagnitude + * magnitude of the left joystick (range 0-1). + * @param lmax1 + * maximum left joystick value 1. + * @param lmax2 + * maximum left joystick value 2. + * @param lmin1 + * minimum left joystick value 1. + * @param lmin2 + * minimum left joystick value 2. + * @param lcenter1 + * center left joystick value 1. + * @param lcenter2 + * center left joystick value 2. + * @param rangle + * angle the right joystick is being held. + * @param rmagnitude + * magnitude of the right joystick (range 0-1). + * @param rmax1 + * maximum right joystick value 1. + * @param rmax2 + * maximum right joystick value 2. + * @param rmin1 + * minimum right joystick value 1. + * @param rmin2 + * minimum right joystick value 2. + * @param rcenter1 + * center right joystick value 1. + * @param rcenter2 + * center right joystick value 2. + */ + public void addClassicControllerEventToPreparedWiimoteEvent(short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, float rightShoulder, + float leftShoulder, float langle, float lmagnitude, short lmax1, + short lmax2, short lmin1, short lmin2, short lcenter1, + short lcenter2, float rangle, float rmagnitude, short rmax1, + short rmax2, short rmin1, short rmin2, short rcenter1, + short rcenter2) { + if (genericEvent != null) { + genericEvent.setClassicControllerEvent(buttonsJustPressed, + buttonsJustReleased, buttonsHeld, rightShoulder, + leftShoulder, langle, lmagnitude, lmax1, lmax2, lmin1, + lmin2, lcenter1, lcenter2, rangle, rmagnitude, rmax1, + rmax2, rmin1, rmin2, rcenter1, rcenter2); + } + } + + public void addBalanceBoardEventToPreparedWiimoteEvent(float topRight, + float bottomRight, float bottomLeft, float topLeft) { + if (genericEvent != null) { + genericEvent.setBalanceBoardEvent(topRight, bottomRight, + bottomLeft, topLeft); + } + } + + /** + * Add the prepared WiimoteEvent to the gatherer. + */ + public void addWiimoteEvent() { + if (genericEvent != null) { + addEvent(genericEvent); + genericEvent = null; + } + } + + /** + * Add a StatusEvent to the gatherer. + * + * @param id + * id of the wiimote. + * @param connect + * true if the wiimote is connected. + * @param batt + * battery level. + * @param led + * status of leds. + * @param speak + * speakers status. + * @param attach + * attachment status. + * @param rumbleState + * true if rumble is active. + * @param continuousState + * true if continuous flag is activated. + * @param irState + * true if ir is active. + * @param motionSensingState + * true if accelerometer is active. + */ + public void addStatusEvent(int id, boolean connect, float batt, short led, + boolean speak, int attach, boolean rumbleState, + boolean continuousState, boolean irState, boolean motionSensingState) { + StatusEvent evt = new StatusEvent(id, connect, batt, led, speak, + attach, rumbleState, continuousState, irState, + motionSensingState); + addEvent(evt); + } + + /** + * Add a DisconnectionEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addDisconnectionEvent(int id) { + DisconnectionEvent evt = new DisconnectionEvent(id); + addEvent(evt); + } + + /** + * Add a NunchukInsertedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addNunchukInsertedEvent(int id) { + NunchukInsertedEvent evt = new NunchukInsertedEvent(id); + addEvent(evt); + } + + /** + * Add a NunchukRemovedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addNunchukRemovedEvent(int id) { + NunchukRemovedEvent evt = new NunchukRemovedEvent(id); + addEvent(evt); + } + + /** + * Add a GuitarHeroInsertedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addGuitarHeroInsertedEvent(int id) { + GuitarHeroInsertedEvent evt = new GuitarHeroInsertedEvent(id); + addEvent(evt); + } + + /** + * Add a GuitarHeroRemovedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addGuitarHeroRemovedEvent(int id) { + GuitarHeroRemovedEvent evt = new GuitarHeroRemovedEvent(id); + addEvent(evt); + } + + /** + * Add a ClassicControllerInsertedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addClassicControllerInsertedEvent(int id) { + ClassicControllerInsertedEvent evt = new ClassicControllerInsertedEvent( + id); + addEvent(evt); + } + + /** + * Add a ClassicControllerRemovedEvent to the gatherer. + * + * @param id + * id of the wiimote. + */ + public void addClassicControllerRemovedEvent(int id) { + ClassicControllerRemovedEvent evt = new ClassicControllerRemovedEvent( + id); + addEvent(evt); + } + + public void addBalanceBoardInsertedEvent(int id) { + BalanceBoardInsertedEvent evt = new BalanceBoardInsertedEvent(id); + addEvent(evt); + } + + public void addBalanceBoardRemovedEvent(int id) { + BalanceBoardRemovedEvent evt = new BalanceBoardRemovedEvent(id); + addEvent(evt); + } + + /** + * Return an array containing the events. + * + * @return events received. + */ + public WiiUseApiEvent[] getEvents() { + WiiUseApiEvent[] ev = new WiiUseApiEvent[index]; + System.arraycopy(events, 0, ev, 0, index); + return ev; + } + + /** + * Clear the gatherer and remove objects. + */ + public void clearEvents() { + for (int i = 0; i < events.length; i++) { + events[i] = null; + } + genericEvent = null; + index = 0; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/utils/WiiUseApiListener.java b/java/src/main/java/wiiusej/wiiusejevents/utils/WiiUseApiListener.java new file mode 100644 index 0000000..b38f0f5 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/utils/WiiUseApiListener.java @@ -0,0 +1,37 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.utils; + +import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent; + +/** + * This is the interface to implement to listen to events from the wiiuse API. + * + * @author guiguito + */ +public interface WiiUseApiListener extends java.util.EventListener { + + /** + * Method called when a WiiUseApiEvent occurs. A WiiUseApiEvent can be : - + * WiimoteEvent (Storing ButtonsEvent and eventually IREvent and + * MotionSensingEvent) - StatusEvent - DisconnectionEvent + * + * @param e + */ + void onWiiUseApiEvent(WiiUseApiEvent e); + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/utils/WiimoteListener.java b/java/src/main/java/wiiusej/wiiusejevents/utils/WiimoteListener.java new file mode 100644 index 0000000..5417ecc --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/utils/WiimoteListener.java @@ -0,0 +1,149 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.utils; + +import wiiusej.wiiusejevents.physicalevents.ExpansionEvent; +import wiiusej.wiiusejevents.physicalevents.IREvent; +import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent; +import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent; +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent; +import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent; + +/** + * This is the interface to implement to listen to events from wiimotes. The + * differents methods are called in this order : onButtonsEvent, onIrEvent, + * onMotionSensingEvent, onExpansionEvent, onStatusEvent, onDisconnectionEvent + * onNunchukInsertedEvent, onNunchukRemovedEvent. + * + * @author guiguito + */ +public interface WiimoteListener extends java.util.EventListener { + + /** + * Method called on a button Event. + * + * @param e + * the buttonEvent with the last informations about the buttons + * of the wiimote. + */ + void onButtonsEvent(WiimoteButtonsEvent e); + + /** + * Method called when an IR event occurs. + * + * @param e + * the IREvent with the IR points seen. + */ + void onIrEvent(IREvent e); + + /** + * Method called when a motion sensing event occurs. + * + * @param e + * the motion sensing event with orientation and acceleration. + */ + void onMotionSensingEvent(MotionSensingEvent e); + + /** + * Method called when an expansion event occurs. + * + * @param e + * the expansion event occured. + */ + void onExpansionEvent(ExpansionEvent e); + + /** + * Method called on a status event. A status event occurs when : - we ask it - + * an expansion controller has been plugged - an expansion controller has + * been unplugged This is where you can get the different values of the + * parameters setup on your wiimote. + * + * @param e + * the status event. + */ + void onStatusEvent(StatusEvent e); + + /** + * This is the method called when a disconnection event occurs. A + * disconnection event happens when : - there are no battery left - the + * wiimote has just been turned off - the connection is dropped + * + * @param e + * the disconnection event. + */ + void onDisconnectionEvent(DisconnectionEvent e); + + /** + * This is the method called when a NunchukInsertedEvent occurs. + * + * @param e + * the NunchukInsertedEvent. + */ + void onNunchukInsertedEvent(NunchukInsertedEvent e); + + /** + * This is the method called when a NunchukRemovedEvent occurs. + * + * @param e + * the NunchukRemovedEvent. + */ + void onNunchukRemovedEvent(NunchukRemovedEvent e); + + + /** + * This is the method called when a GuitarHeroInsertedEvent occurs. + * + * @param e + * the GuitarHeroInsertedEvent. + */ + void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent e); + + /** + * This is the method called when a GuitarHeroRemovedEvent occurs. + * + * @param e + * the GuitarHeroRemovedEvent. + */ + void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent e); + + /** + * This is the method called when a ClassicControllerInsertedEvent occurs. + * + * @param e + * the ClassicControllerInsertedEvent. + */ + void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent e); + + /** + * This is the method called when a ClassicControllerRemovedEvent occurs. + * + * @param e + * the ClassicControllerRemovedEvent. + */ + void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent e); + + void onBalanceBoardInsertedEvent(BalanceBoardInsertedEvent e); + void onBalanceBoardRemovedEvent(BalanceBoardRemovedEvent e); +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardInsertedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardInsertedEvent.java new file mode 100644 index 0000000..39e590e --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardInsertedEvent.java @@ -0,0 +1,15 @@ +package wiiusej.wiiusejevents.wiiuseapievents; + +public class BalanceBoardInsertedEvent extends WiiUseApiEvent { + public BalanceBoardInsertedEvent(int id) { + super(id, WIIUSE_BALANCE_BOARD_CTRL_INSERTED); + } + + public String toString() { + String out = ""; + /* Status */ + out += "/*********** BALANCE BOARD INSERTED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardRemovedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardRemovedEvent.java new file mode 100644 index 0000000..04cd14d --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/BalanceBoardRemovedEvent.java @@ -0,0 +1,17 @@ +package wiiusej.wiiusejevents.wiiuseapievents; + +import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent; + +public class BalanceBoardRemovedEvent extends WiiUseApiEvent { + public BalanceBoardRemovedEvent(int id) { + super(id, WIIUSE_BALANCE_BOARD_CTRL_REMOVED); + } + + public String toString() { + String out = ""; + /* Status */ + out += "/*********** BALANCE BOARD INSERTED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerInsertedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerInsertedEvent.java new file mode 100644 index 0000000..f61be56 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerInsertedEvent.java @@ -0,0 +1,46 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the connection of a classic controller to a wiimote. + * + * @author guiguito + * + */ +public class ClassicControllerInsertedEvent extends WiiUseApiEvent { + + /** + * Construct the ClassicControllerInsertedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public ClassicControllerInsertedEvent(int id) { + super(id, WIIUSE_CLASSIC_CTRL_INSERTED); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** CLASSIC CONTROLLER INSERTED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerRemovedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerRemovedEvent.java new file mode 100644 index 0000000..d3407bc --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerRemovedEvent.java @@ -0,0 +1,47 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the disconnection of a classic controller from a + * wiimote. + * + * @author guiguito + * + */ +public class ClassicControllerRemovedEvent extends WiiUseApiEvent { + + /** + * Construct the ClassicControllerRemovedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public ClassicControllerRemovedEvent(int id) { + super(id, WIIUSE_CLASSIC_CTRL_REMOVED); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** CLASSIC CONTROLLER REMOVED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/DisconnectionEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/DisconnectionEvent.java new file mode 100644 index 0000000..660642f --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/DisconnectionEvent.java @@ -0,0 +1,45 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Class representing a disconnection event. + * + * @author guiguito + */ +public class DisconnectionEvent extends WiiUseApiEvent { + + /** + * Construct the DisconnectionEvent setting up the id. + * + * @param id + * the Wiimote id + */ + public DisconnectionEvent(int id) { + super(id, WiiUseApiEvent.DISCONNECTION_EVENT); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** DISCONNECTION EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroInsertedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroInsertedEvent.java new file mode 100644 index 0000000..4fb041e --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroInsertedEvent.java @@ -0,0 +1,47 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the connection of a Guitar hero controller to a + * wiimote. + * + * @author guiguito + * + */ +public class GuitarHeroInsertedEvent extends WiiUseApiEvent { + + /** + * Construct the GuitarHeroInsertedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public GuitarHeroInsertedEvent(int id) { + super(id, WIIUSE_GUITAR_HERO_3_CTRL_INSERTED); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** GUITAR HERO INSERTED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroRemovedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroRemovedEvent.java new file mode 100644 index 0000000..c8c6a95 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroRemovedEvent.java @@ -0,0 +1,47 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the disconnection of a guitar hero controller from a + * wiimote. + * + * @author guiguito + * + */ +public class GuitarHeroRemovedEvent extends WiiUseApiEvent { + + /** + * Construct the GuitarHeroRemovedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public GuitarHeroRemovedEvent(int id) { + super(id, WIIUSE_GUITAR_HERO_3_CTRL_REMOVED); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** GUITAR HERO REMOVED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukInsertedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukInsertedEvent.java new file mode 100644 index 0000000..a4a388b --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukInsertedEvent.java @@ -0,0 +1,51 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the connection of a nunchuk to a wiimote. + * + * @author guiguito + * + */ +public class NunchukInsertedEvent extends WiiUseApiEvent { + + /** + * Construct the NunchukInsertedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public NunchukInsertedEvent(int id) { + super(id, WIIUSE_NUNCHUK_INSERTED); + } + + /* + * (non-Javadoc) + * + * @see wiiusej.wiiusejevents.WiiUseApiEvent#toString() + */ + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** NUNCHUK INSERTED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukRemovedEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukRemovedEvent.java new file mode 100644 index 0000000..9173c86 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/NunchukRemovedEvent.java @@ -0,0 +1,50 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Event that represents the disconnection of a nunchuk from a wiimote. + * + * @author guiguito + */ +public class NunchukRemovedEvent extends WiiUseApiEvent { + + /** + * Construct the NunchukInsertedEvent setting up the id. + * + * @param id + * id of the wiimote. + */ + public NunchukRemovedEvent(int id) { + super(id, WIIUSE_NUNCHUK_REMOVED); + } + + /* + * (non-Javadoc) + * + * @see wiiusej.wiiusejevents.WiiUseApiEvent#toString() + */ + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** NUNCHUK REMOVED EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/StatusEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/StatusEvent.java new file mode 100644 index 0000000..4544845 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/StatusEvent.java @@ -0,0 +1,293 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +/** + * Class used to represent a status event. This class is used to know what are + * the settings of the wiimote. + * + * @author guiguito + */ +public class StatusEvent extends WiiUseApiEvent { + + protected static short WIIMOTE_LED_1 = 1; + protected static short WIIMOTE_LED_2 = 2; + protected static short WIIMOTE_LED_3 = 4; + protected static short WIIMOTE_LED_4 = 8; + + /* ATTACHMENT CONSTANTS */ + + private static short EXP_NONE = 0; + private static short EXP_NUNCHUK = 1; + private static short EXP_CLASSIC = 2; + private static short EXP_GUITAR_HERO_3 = 3; + + /* Status variables */ + private boolean connected = false; + + private float batteryLevel = -1; + + private short leds = 0; + + private boolean isSpeakerEnabled = false; + + private int attachment = 0; + + private boolean isRumbleActive = false; + + private boolean isContinuousActive = false; + + private boolean isIrActive = false; + + private boolean isMotionSensingActive = false; + + /** + * Construct the StatusEvent setting up the id. + * + * @param id + * the Wiimote id + */ + public StatusEvent(int id) { + super(id, WiiUseApiEvent.STATUS_EVENT); + } + + /** + * Build a StatusEvent with all fields set. + * + * @param id + * id of the wiimote + * @param connect + * true if the wiimote is connected + * @param batt + * battery level + * @param led + * status of leds + * @param speak + * speakers status + * @param attach + * attachment status + * @param rumbleState + * true if rumble is active + * @param continuousState + * true if continuous flag is activated + * @param irState + * true if ir is active + * @param motionSensingState + * true if accelerometer is active + */ + public StatusEvent(int id, boolean connect, float batt, short led, + boolean speak, int attach, boolean rumbleState, + boolean continuousState, boolean irState, boolean motionSensingState) { + super(id, WiiUseApiEvent.STATUS_EVENT); + connected = connect; + this.batteryLevel = batt; + this.leds = led; + this.isSpeakerEnabled = speak; + this.attachment = attach; + isRumbleActive = rumbleState; + isContinuousActive = continuousState; + isIrActive = irState; + isMotionSensingActive = motionSensingState; + } + + /** + * True if the wiimote is connected false otherwise. + * + * @return return the connected status. + */ + public boolean isConnected() { + return connected; + } + + /** + * Get battery level. + * + * @return battery level. 1 = 100% + */ + public float getBatteryLevel() { + return batteryLevel; + } + + /** + * Get status of the leds . + * + * @return a short representing LEDS turned on. + */ + public short getLeds() { + return leds; + } + + /** + * Tells if the given led is turned on according to the leds status int. + * + * @param led + * the int encoding a led. + * @return true if the led is turned on false otherwise. + */ + private boolean ledStatusCheck(short led) { + if ((leds & led) > 0) { + return true; + } else { + return false; + } + } + + /** + * Get led1 status. + * + * @return true if the led is set. + */ + public boolean isLed1Set() { + return ledStatusCheck(WIIMOTE_LED_1); + } + + /** + * Get led2 status. + * + * @return true if the led is set. + */ + public boolean isLed2Set() { + return ledStatusCheck(WIIMOTE_LED_2); + } + + /** + * Get led3 status. + * + * @return true if the led is set. + */ + public boolean isLed3Set() { + return ledStatusCheck(WIIMOTE_LED_3); + } + + /** + * Get led4 status. + * + * @return true if the led is set. + */ + public boolean isLed4Set() { + return ledStatusCheck(WIIMOTE_LED_4); + } + + /** + * Tell if the speaker is enable for this wiimote + * + * @return TRUE if it enabled false otherwise + */ + public boolean isSpeakerEnabled() { + return isSpeakerEnabled; + } + + /** + * Get the int representing the attachment type. + * + * @return value of the Attachment Type + */ + public int getAttachment() { + return attachment; + } + + /** + * Get the status of rumble. + * + * @return true if the rumble is active false otherwise + */ + public boolean isRumbleActive() { + return isRumbleActive; + } + + /** + * Tell if the CONTINUOUS option is activated. + * + * @return the isContinuousActive + */ + public boolean isContinuousActive() { + return isContinuousActive; + } + + /** + * Tell if the IR Tracking is active. + * + * @return TRUE if it is active or false otherwise. + */ + public boolean isIrActive() { + return isIrActive; + } + + /** + * Get the flag indicating if the motion sensing is active. + * + * @return true if the motion sensing is active false otherwise + */ + public boolean isMotionSensingActive() { + return isMotionSensingActive; + } + + /** + * Tells if an attachment is connected. + * + * @return true if anything is connected to the wiimote false otherwise. + */ + public boolean isAttachmentConnected() { + return attachment == EXP_NONE; + } + + /** + * Tells if a nunchuk is connected. + * + * @return true if a nunchuk is connected to the wiimote false otherwise. + */ + public boolean isNunchukConnected() { + return attachment == EXP_NUNCHUK; + } + + /** + * Tells if a classic controller is connected. + * + * @return true if a classic controller is connected to the wiimote false otherwise. + */ + public boolean isClassicControllerConnected() { + return attachment == EXP_CLASSIC; + } + + /** + * Tells if a guitar hero controller is connected. + * + * @return true if a guitar hero controllerr is connected to the wiimote false otherwise. + */ + public boolean isGuitarHeroConnected() { + return attachment == EXP_GUITAR_HERO_3; + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** STATUS EVENT : WIIMOTE ID :" + + super.getWiimoteId() + " ********/\n"; + out += "--- connected : " + connected + "\n"; + out += "--- Battery level : " + batteryLevel + "\n"; + out += "--- Leds : " + leds + "\n"; + out += "--- Speaker enabled : " + isSpeakerEnabled + "\n"; + out += "--- Attachment ? : " + attachment + "\n"; + out += "--- Rumble ? : " + isRumbleActive + "\n"; + out += "--- Continuous ? : " + isContinuousActive + "\n"; + out += "--- IR active ? : " + isIrActive + "\n"; + out += "--- Motion sensing active ? : " + isMotionSensingActive + "\n"; + return out; + } + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiiUseApiEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiiUseApiEvent.java new file mode 100644 index 0000000..c122428 --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiiUseApiEvent.java @@ -0,0 +1,67 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +import wiiusej.wiiusejevents.GenericEvent; + +/** + * This class describes the structure of an event from the WiiUse API event. + * + * @author guiguito + */ +public abstract class WiiUseApiEvent extends GenericEvent{ + public static int NONE_EVENT = 0; + public static int GENERIC_EVENT = 1; + public static int STATUS_EVENT = 2; + public static int DISCONNECTION_EVENT = 3; + public static int WIIUSE_READ_DATA = 4; + public static int WIIUSE_NUNCHUK_INSERTED = 5; + public static int WIIUSE_NUNCHUK_REMOVED = 6; + public static int WIIUSE_CLASSIC_CTRL_INSERTED = 7; + public static int WIIUSE_CLASSIC_CTRL_REMOVED = 8; + public static int WIIUSE_GUITAR_HERO_3_CTRL_INSERTED = 9; + public static int WIIUSE_GUITAR_HERO_3_CTRL_REMOVED = 10; + public static int WIIUSE_BALANCE_BOARD_CTRL_INSERTED = 11; + public static int WIIUSE_BALANCE_BOARD_CTRL_REMOVED = 12; + + /* Event Type */ + private int eventType; + + /** + * Construct the WiiUseApiEvent setting up the id. + * + * @param id + * the Wiimote id + * @param type + * type of the event + */ + public WiiUseApiEvent(int id, int type) { + super(id); + eventType = type; + } + + /** + * Get the event type. + * @return the eventType + */ + public int getEventType() { + return eventType; + } + + public abstract String toString(); + +} diff --git a/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiimoteEvent.java b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiimoteEvent.java new file mode 100644 index 0000000..349415d --- /dev/null +++ b/java/src/main/java/wiiusej/wiiusejevents/wiiuseapievents/WiimoteEvent.java @@ -0,0 +1,447 @@ +/** + * This file is part of WiiuseJ. + * + * WiiuseJ is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * WiiuseJ is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with WiiuseJ. If not, see . + */ +package wiiusej.wiiusejevents.wiiuseapievents; + +import wiiusej.wiiusejevents.physicalevents.BalanceBoardEvent; +import wiiusej.wiiusejevents.physicalevents.ClassicControllerEvent; +import wiiusej.wiiusejevents.physicalevents.ExpansionEvent; +import wiiusej.wiiusejevents.physicalevents.GuitarHeroEvent; +import wiiusej.wiiusejevents.physicalevents.IREvent; +import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent; +import wiiusej.wiiusejevents.physicalevents.NunchukEvent; +import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent; + +/** + * Class that is a bean to be filled by the wiiuse API on an event that occurs + * on a wiimote. + * + * @author guiguito + */ +public class WiimoteEvent extends WiiUseApiEvent { + + private WiimoteButtonsEvent buttonsEvent = null; + private IREvent infraredEvent = null; + private MotionSensingEvent motionSensingEvent = null; + private ExpansionEvent expansionEvent = null; + + /** + * Construct the Wiimote setting up the id. + * + * @param id + * the Wiimote id + */ + public WiimoteEvent(int id) { + super(id, WiiUseApiEvent.GENERIC_EVENT); + } + + /** + * Construct the Wiimote setting up the id and the buttons. + * + * @param id + * the Wiimote id + * @param buttonsJustPressed + * buttons just pressed + * @param buttonsJustReleased + * buttons just released + * @param buttonsHeld + * buttons held + */ + public WiimoteEvent(int id, short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld) { + super(id, WiiUseApiEvent.GENERIC_EVENT); + buttonsEvent = new WiimoteButtonsEvent(id, buttonsJustPressed, + buttonsJustReleased, buttonsHeld); + } + + /** + * Tell if there is an IR Event. + * + * @return TRUE if there is an IR event. + */ + public boolean isThereIrEvent() { + return infraredEvent != null; + } + + /** + * Tell if there is a motion sensing Event. + * + * @return TRUE if there is a motion sensing event. + */ + public boolean isThereMotionSensingEvent() { + return motionSensingEvent != null; + } + + /** + * Tell if there is an expansion Event. + * + * @return TRUE if there is an expansion event. + */ + public boolean isThereExpansionEvent() { + return expansionEvent != null; + } + + /** + * Get buttons event. + * + * @return the buttons event. + */ + public WiimoteButtonsEvent getButtonsEvent() { + return buttonsEvent; + } + + /** + * Get the IR event. + * + * @return the IR event if there is one or null. + */ + public IREvent getIREvent() { + return infraredEvent; + } + + /** + * Get the motion sensing event. + * + * @return the motion sensing event if there is one or null. + */ + public MotionSensingEvent getMotionSensingEvent() { + return motionSensingEvent; + } + + /** + * Get the expansion event. + * + * @return the expansion event if there is one or null. + */ + public ExpansionEvent getExpansionEvent() { + return expansionEvent; + } + + /** + * Prepare an IR event to populate. + * + * @param x + * calculated X coordinate. + * @param y + * calculated Y coordinate. + * @param z + * calculated distance. + * @param ax + * absolute X coordinate. + * @param ay + * absolute Y coordinate + * @param xVRes + * IR virtual screen x resolution. + * @param yVRes + * IR virtual screen y resolution. + * @param xOffset + * IR X correction offset. + * @param yOffset + * IR Y correction offset. + * @param sensorBarPostion + * aspect ratio of the screen. + * @param screenAsPectRatio + * IR sensor bar position. + * @param irSensitivity + * Sensitivity of the infrared camera. + * @param distance + * Pixel Distance between first two dots + */ + public void prepareIRevent(int x, int y, float z, int ax, int ay, + int xVRes, int yVRes, int xOffset, int yOffset, + short sensorBarPostion, short screenAsPectRatio, + short irSensitivity, float distance) { + if (infraredEvent == null) { + infraredEvent = new IREvent(getWiimoteId(), x, y, z, ax, ay, xVRes, + yVRes, xOffset, yOffset, sensorBarPostion, + screenAsPectRatio, irSensitivity, distance); + } + } + + /** + * Add an IR point to the generic event. Create an IR Event if it's not + * created yet. + * + * @param x + * x coordinates. + * @param y + * y coordinates + * @param rx + * raw X coordinate (0-1023). + * @param ry + * raw Y coordinate (0-1023). + * @param size + * size of the IR dot (0-15). + */ + public void addIRpoint(int x, int y, short rx, short ry, short size) { + if (infraredEvent != null) + infraredEvent.addIRpoint(x, y, rx, ry, size); + } + + /** + * Set the Motion Sensing Event. + * + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + */ + public void setMotionSensingEvent(float orientationThreshold, + int accelerationThreshold, boolean smoothingState, + float alphaSmooth, float r, float p, float ya, float ar, float ap, + float x, float y, float z, short xx, short yy, short zz) { + motionSensingEvent = new MotionSensingEvent(getWiimoteId(), + orientationThreshold, accelerationThreshold, smoothingState, + alphaSmooth, r, p, ya, ar, ap, x, y, z, xx, yy, zz); + } + + /** + * Set a NunchukEvent for the expansion event. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param orientationThreshold + * value of the minimum angle between two events with the + * accelerometer. + * @param accelerationThreshold + * value of the value variation between two events with the + * accelerometer. + * @param smoothingState + * true if smoothing flag is activated. + * @param alphaSmooth + * value of the alpha smoothing parameter. + * @param r + * roll. + * @param p + * pitch. + * @param ya + * yaw. + * @param ar + * absolute roll. + * @param ap + * absolute pitch. + * @param x + * gravity force on x axis. + * @param y + * gravity force on y axis. + * @param z + * gravity force on z axis. + * @param xx + * raw acceleration on x axis. + * @param yy + * raw acceleration on y axis. + * @param zz + * raw acceleration on z axis. + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public void setNunchukEvent(short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, + float orientationThreshold, int accelerationThreshold, + boolean smoothingState, float alphaSmooth, float r, float p, + float ya, float ar, float ap, float x, float y, float z, short xx, + short yy, short zz, float angle, float magnitude, short max1, + short max2, short min1, short min2, short center1, short center2) { + expansionEvent = new NunchukEvent(getWiimoteId(), buttonsJustPressed, + buttonsJustReleased, buttonsHeld, orientationThreshold, + accelerationThreshold, smoothingState, alphaSmooth, r, p, ya, + ar, ap, x, y, z, xx, yy, zz, angle, magnitude, max1, max2, + min1, min2, center1, center2); + } + + /** + * Set a ClassicControllerEvent for the expansionEvent. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param rightShoulder + * right shoulder button (range 0-1). + * @param leftShoulder + * left shoulder button (range 0-1). + * @param langle + * angle the left joystick is being held. + * @param lmagnitude + * magnitude of the left joystick (range 0-1). + * @param lmax1 + * maximum left joystick value 1. + * @param lmax2 + * maximum left joystick value 2. + * @param lmin1 + * minimum left joystick value 1. + * @param lmin2 + * minimum left joystick value 2. + * @param lcenter1 + * center left joystick value 1. + * @param lcenter2 + * center left joystick value 2. + * @param rangle + * angle the right joystick is being held. + * @param rmagnitude + * magnitude of the right joystick (range 0-1). + * @param rmax1 + * maximum right joystick value 1. + * @param rmax2 + * maximum right joystick value 2. + * @param rmin1 + * minimum right joystick value 1. + * @param rmin2 + * minimum right joystick value 2. + * @param rcenter1 + * center right joystick value 1. + * @param rcenter2 + * center right joystick value 2. + */ + public void setClassicControllerEvent(short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, float rightShoulder, + float leftShoulder, float langle, float lmagnitude, short lmax1, + short lmax2, short lmin1, short lmin2, short lcenter1, + short lcenter2, float rangle, float rmagnitude, short rmax1, + short rmax2, short rmin1, short rmin2, short rcenter1, + short rcenter2) { + expansionEvent = new ClassicControllerEvent(getWiimoteId(), + buttonsJustPressed, buttonsJustReleased, buttonsHeld, + rightShoulder, leftShoulder, langle, lmagnitude, lmax1, lmax2, + lmin1, lmin2, lcenter1, lcenter2, rangle, rmagnitude, rmax1, + rmax2, rmin1, rmin2, rcenter1, rcenter2); + } + + /** + * Set a GuitarHeroEvent for the expansionEvent. + * + * @param buttonsJustPressed + * buttons just pressed. + * @param buttonsJustReleased + * buttons just released. + * @param buttonsHeld + * buttons just pressed. + * @param whammyBar + * whammy bar (range 0-1). + * @param angle + * angle the joystick is being held. + * @param magnitude + * magnitude of the joystick (range 0-1). + * @param max1 + * maximum joystick value 1. + * @param max2 + * maximum joystick value 2. + * @param min1 + * minimum joystick value 1. + * @param min2 + * minimum joystick value 2. + * @param center1 + * center joystick value 1. + * @param center2 + * center joystick value 2. + */ + public void setGuitarHeroEvent(short buttonsJustPressed, + short buttonsJustReleased, short buttonsHeld, float whammyBar, + float angle, float magnitude, short max1, short max2, short min1, + short min2, short center1, short center2) { + expansionEvent = new GuitarHeroEvent(getWiimoteId(), + buttonsJustPressed, buttonsJustReleased, buttonsHeld, + whammyBar, angle, magnitude, max1, max2, min1, min2, center1, + center2); + } + + public void setBalanceBoardEvent(float topRight, float bottomRight, + float bottomLeft, float topLeft) { + expansionEvent = new BalanceBoardEvent(getWiimoteId(), topRight, + bottomRight, bottomLeft, topLeft); + } + + @Override + public String toString() { + String out = ""; + /* Status */ + out += "/*********** GENERIC EVENT : WIIMOTE ID :" + getWiimoteId() + + " ********/\n"; + + out += buttonsEvent; + + if (infraredEvent != null) { + out += infraredEvent; + } else { + out += "/******** IR Tracking ********/\n"; + out += "--- Active : false\n"; + } + + if (motionSensingEvent != null) { + out += motionSensingEvent; + } else { + out += "/******** Motion sensing ********/\n"; + out += "--- Motion sensing : false \n"; + } + + if (expansionEvent != null) { + out += expansionEvent; + } else { + out += "/******** Expansion ********/\n"; + out += "--- No expansion connected \n"; + } + + return out; + } +} diff --git a/java/wiiuse.dll b/java/wiiuse.dll new file mode 100644 index 0000000..512c0cc Binary files /dev/null and b/java/wiiuse.dll differ diff --git a/java/wiiusej.dll b/java/wiiusej.dll new file mode 100644 index 0000000..12261bc Binary files /dev/null and b/java/wiiusej.dll differ