diff options
Diffstat (limited to 'plugins/DX8')
| -rw-r--r-- | plugins/DX8/README.txt | 46 | ||||
| -rw-r--r-- | plugins/DX8/build.xml | 103 | ||||
| -rw-r--r-- | plugins/DX8/src/java/net/java/games/input/DirectInputAxis.java | 211 | ||||
| -rw-r--r-- | plugins/DX8/src/java/net/java/games/input/DirectInputDevice.java | 207 | ||||
| -rw-r--r-- | plugins/DX8/src/java/net/java/games/input/DirectInputEnvironmentPlugin.java | 183 | ||||
| -rw-r--r-- | plugins/DX8/src/java/net/java/games/input/DirectInputKeyboard.java | 208 | ||||
| -rw-r--r-- | plugins/DX8/src/java/net/java/games/input/DirectInputMouse.java | 311 | ||||
| -rw-r--r-- | plugins/DX8/src/native/input.cpp | 888 |
8 files changed, 2157 insertions, 0 deletions
diff --git a/plugins/DX8/README.txt b/plugins/DX8/README.txt new file mode 100644 index 0000000..12cd468 --- /dev/null +++ b/plugins/DX8/README.txt @@ -0,0 +1,46 @@ +This file modified last on 06/06/2003 by Jeff Kesselman + +This is the source tree for the core input API. + +Directory Organization: + +The root contains a master ANT build.xml. +After a successful build you will have the following sub directories: + -- apidocs Where the javadocs get built to + -- lib Where dependant libraries are kept. + -- bin Where the plugin dll and jar files ar built to. + -- src The source files. + + +Build instructions: + +To clean: ant clean +To build: ant all (or just ant) +To build docs: ant javadoc +To test: + This build will install the plug-in into the coreAPI's test + directories. + Use the tests in the coreAPI build.xml to test. + +Release Info: + Initial Release: This release contains an implementation of the input + API designed by Mike Martak of Sun and Thomas (?) of Sony CEA for + the WIn32 platform. All the code in src/input is cross platform. The + Win32 code is segregated to the DirectX plugin (src/DXplugin) which + depends on DirectInput from DX7 (or later). + + 05/09/2003: A number of bugs and problems with the DXPlugin are fixed in this + release. This release also brings the code up to date using the DI8 + interface. This thus is the first release that requries Peter Puck's + DX8 bindings to compile with MinGW. + + 05/09/2003 (second update): + This version adds a new standard value type to the API. + Axis.POV holds standard definitions for values for POV (hat) switches + -- Axis.POV.CENTER and Axis.POV.OFF are synonmous and are + the center position. + -- Axis.POV.UP, Axis.POV.DOWN, Axis.POV.LEFT and Axis.POV.RIGHT + should be self explainatory. + Any hat that claims to be "normalized" will return these values. (It is + recommended that all hats be normalized by the systemn specific plugins.) + diff --git a/plugins/DX8/build.xml b/plugins/DX8/build.xml new file mode 100644 index 0000000..32001e1 --- /dev/null +++ b/plugins/DX8/build.xml @@ -0,0 +1,103 @@ +<?xml version="1.0"?> + +<!-- Written to assume that classpath is rooted in the current directory. --> +<!-- So this should be OK if you make this script in the root of a filesystem. --> +<!-- If not, you may prefer to adjust the basedir, or move some directories around. --> +<!-- The idea is that both Ant and NetBeans have to know what the package root is --> +<!-- for the classes in your application. --> +<project name="Direct Input Plugin" basedir="." default="all"> + + <!-- Don't worry if you don't know the Ant syntax completely or need help on some tasks! --> + <!-- The standard Ant documentation is bundled. See Help | Help Sets | Ant 1.4.1 Manual. --> + + <target name="init"> + <!-- You can set up any variables you want used throughout the script here. --> + <property name="hello" value="world"/> + <mkdir dir="classes"/> + <mkdir dir="bin"/> + <!-- To use e.g. Jikes, uncomment this line. --> + <!-- (Or make the same change in Tools | Options | Ant Settings | Properties.) --> + <!-- <property name="build.compiler" value="jikes"/> --> + <!-- You might like to set up some overridable paths, etc.: --> + <!-- <property name="mylib" value="../lib/mylib.jar"/> --> + </target> + + <target name="compile" depends="init"> + <!-- Both srcdir and destdir should be package roots. --> + <!-- They could be different of course; in that case NetBeans can also be set --> + <!-- up to compile to a different filesystem in the same way; see Compiler Types: --> + <javac srcdir="src/java" destdir="classes" debug="true" deprecation="true" source="1.4"> + <!-- To add something to the classpath: --> + <classpath> + <pathelement location="lib/controller.jar"/> + <pathelement location="lib/jutils.jar"/> + </classpath> + <!-- To exclude some files: --> + <!-- + <exclude name="com/foo/SomeFile.java"/> + <exclude name="com/foo/somepackage/"/> + --> + </javac> + <exec dir="." executable="gcc" os="Windows 2000"> + <arg line=" -D_STRICT_ANSI -D_JNI_IMPLEMENTATION_"/> + <arg line=" -I'${java.home}/../include' -I'${java.home}/../include/win32' -Ic:/dx9/include"/> + <arg line=" -o bin/dxinput.dll src/native/input.cpp -Wl,--export-all-symbols"/> + <arg line=" -shared -Wl,--kill-at -ldxguid -ldinput -ldinput8"/> + </exec> + <copy file="bin/dxinput.dll" todir="../../coreAPI/src/tests/controller" /> + </target> + + <target name="jar" depends="init,compile"> + <!-- To make a standalone app: --> + <!-- 1. Create a myapp.mf manifest somewhere. --> + <!-- 2. Put in it: --> + <!-- Manifest-Version: 1.0 --> + <!-- Main-Class: com.foo.Main --> + <!-- 3. Pass to <jar>: manifest="myapp.mf" --> + <jar jarfile="bin/dxinput.jar" compress="true" basedir="classes"> + <exclude name="**/*.java"/> + <exclude name="**/*.form"/> + <exclude name="dxinput.mf"/> + <exclude name="dxinput.jar"/> + <exclude name="apidoc"/> + </jar> + <copy file="bin/dxinput.jar" todir="../../coreAPI/src/tests/controller" /> + </target> + + <target name="all" depends="compile,jar" description="Build everything."> + <echo message="Application built. Hello ${hello}!"/> + </target> + + <target name="test" depends="init,all" description="Try running it."> + <echo message="Test by running test on the build.xml for input"/> + </target> + + <target name="javadoc" depends="init" description="Javadoc for my API."> + <mkdir dir="apidocs"/> + <javadoc packagenames="net.*" + destdir="apidocs" + additionalparam="-source 1.4"> + <sourcepath> + <pathelement location="src/java"/> + </sourcepath> + <classpath> + <pathelement location="lib/controller.jar"/> + <pathelement location="lib/jutils.jar"/> + </classpath> + </javadoc> + </target> + + <target name="clean" depends="init" description="Clean all build products."> + <delete> + <fileset dir="classes"> + <include name="**/*.class"/> + </fileset> + </delete> + <delete file="bin/dxinput.jar" failonerror="no"/> + <delete file="bin/dxinput.dll" failonerror="no"/> + <delete file="../../coreAPI/src/tests/controller/dxinput.jar" failonerror="no" /> + <delete file="../../coreAPI/src/test/controller/dxinput.dll" failonerror="no"/> + <delete dir="../../docs/input/win32/apidoc" failonerror="no"/> + </target> + +</project> diff --git a/plugins/DX8/src/java/net/java/games/input/DirectInputAxis.java b/plugins/DX8/src/java/net/java/games/input/DirectInputAxis.java new file mode 100644 index 0000000..58df37d --- /dev/null +++ b/plugins/DX8/src/java/net/java/games/input/DirectInputAxis.java @@ -0,0 +1,211 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ +/***************************************************************************** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materails provided with the distribution. + * + * Neither the name Sun Microsystems, Inc. or the names of the contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND + * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS + * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST + * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, + * INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY + * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for us in + * the design, construction, operation or maintenance of any nuclear facility + * + *****************************************************************************/ +package net.java.games.input; + +import net.java.games.input.AbstractAxis; +import net.java.games.input.Axis; + +/** + * + * @author martak + * @version + */ +class DirectInputAxis extends AbstractAxis { + + /** + * DIDFT_ constants and macros defined in dinput.h + */ + private static final int DIDFT_ALL = 0x00000000; + private static final int DIDFT_RELAXIS = 0x00000001; + private static final int DIDFT_ABSAXIS = 0x00000002; + private static final int DIDFT_AXIS = 0x00000003; + private static final int DIDFT_PSHBUTTON = 0x00000004; + private static final int DIDFT_TGLBUTTON = 0x00000008; + private static final int DIDFT_BUTTON = 0x0000000C; + private static final int DIDFT_POV = 0x00000010; + private static final int DIDFT_COLLECTION = 0x00000040; + private static final int DIDFT_NODATA = 0x00000080; + private static final int DIDFT_ANYINSTANCE = 0x00FFFF00; + private static final int DIDFT_INSTANCEMASK = DIDFT_ANYINSTANCE; + private static final int DIDFT_FFACTUATOR = 0x01000000; + private static final int DIDFT_FFEFFECTTRIGGER = 0x02000000; + private static final int DIDFT_OUTPUT = 0x10000000; + private static final int DIDFT_NOCOLLECTION = 0x00FFFF00; + private static int DIDFT_MAKEINSTANCE(int n) { + return ((n&0xffff) << 8); + } + private static int DIDFT_GETTYPE(int n) { + return (n&0xFF); + } + private static int DIDFT_GETINSTANCE(int n) { + return ((n >> 8)&0xffff); + } + private static int DIDFT_ENUMCOLLECTION(int n) { + return ((n&0xFFFF) << 8); + } + + private DirectInputDevice device; + /** + * DIJOYSTATE structure defined in dinput.h: + * + * <pre> + * typedef struct DIJOYSTATE { + * LONG lX; + * LONG lY; + * LONG lZ; + * LONG lRx; + * LONG lRy; + * LONG lRz; + * LONG rglSlider[2]; + * DWORD rgdwPOV[4]; + * BYTE rgbButtons[32]; + * } DIJOYSTATE, *LPDIJOYSTATE; + * + * 80 bytes total + * </pre> + */ + private int offset; + private int type; + private int instance; + private int bitmask = 0xffffffff; + private int bitshift = 0; + + private DirectInputAxis(DirectInputDevice device, Axis.Identifier id, + int didft, String name) { + super(name, id); + this.device = device; + this.type = DIDFT_GETTYPE(didft); + this.instance = DIDFT_GETINSTANCE(didft); + if (id == Axis.Identifier.X) { + offset = 0; + } else if (id == Axis.Identifier.Y) { + offset = 1; + } else if (id == Axis.Identifier.Z) { + offset = 2; + } else if (id == Axis.Identifier.RX) { + offset = 3; + } else if (id == Axis.Identifier.RY) { + offset = 4; + } else if (id == Axis.Identifier.RZ) { + offset = 5; + } else if (id == Axis.Identifier.SLIDER) { + //System.out.println("Slider on "+name+" instance = "+instance); + offset = 6 + (instance>>2); + } else if (id == Axis.Identifier.POV) { + //System.out.println("POV on "+name+" instance = "+instance); + offset = 8 + instance; + } else if (id == Axis.Identifier.BUTTON) { + //System.out.println("Button on "+name+" instance = "+instance); + offset = 12 + (instance/4); + bitshift = (instance%4)*8; + bitmask=0xff; + } + } + + /** Returns the data from the last time the control has been polled. + * If this axis is a button, the value returned will be either 0.0f or 1.0f. + * If this axis is normalized, the value returned will be between -1.0f and + * 1.0f. + * @return A float between -1.0 and 1.0 + */ + public float getPollData() { + int data = ((device.data[offset] >> bitshift)&bitmask); + if ((type&DIDFT_BUTTON) != 0 ) { + return (float)((data&0x80)>>7); + } else if ((type&DIDFT_AXIS)!=0){ // all axes are set for -32768 to 32738 + return ((float)data)/32768; + } else if ((type&DIDFT_POV)!=0) { + if (data == -1) { + return Axis.POV.OFF; + } else if (data == 0.0) { + return Axis.POV.UP; + } else if (data == 9000) { + return Axis.POV.RIGHT; + } else if (data == 18000) { + return Axis.POV.DOWN; + } else if (data == 27000) { + return Axis.POV.LEFT; + } else { + System.err.print("Unexpected value for DX8 HAT: "+data); + return Axis.POV.OFF; + } + } else { // return raw value + return (float)data; + } + + } + + /** Returns <code>true</code> if data returned from <code>poll</code> + * is relative to the last call, or <code>false</code> if data + * is absolute. + * @return true if data has chnaged since last poll, else false + */ + public boolean isRelative() { + return (type & DIDFT_RELAXIS) != 0; + } + + /** Returns whether or not the axis is analog, or false if it is digital. + * @return true if analog, false if digital + */ + public boolean isAnalog() { + return (type & DIDFT_AXIS) != 0; + } + + /** Returns whether or not data polled from this axis is normalized + * between the values of -1.0f and 1.0f. + * @return true if data is normalized, false if not. + */ + public boolean isNormalized() { + return (type & (DIDFT_BUTTON|DIDFT_AXIS|DIDFT_POV)) != 0; + } + + /** Creates a new DirectInputAxis (factory method). + * This is a function used internally during set up + * @return The new DirectInputAxis object. + * @param device The device to attach this axis to. + * + * @param didft The identifier for the axis as provided by DX8. + * @param name A name to give the new axis. + * @param id The identifier for the device + */ + public static DirectInputAxis createAxis(DirectInputDevice device, + Axis.Identifier id, int didft, String name) { + return new DirectInputAxis(device, id, didft, name); + } +} diff --git a/plugins/DX8/src/java/net/java/games/input/DirectInputDevice.java b/plugins/DX8/src/java/net/java/games/input/DirectInputDevice.java new file mode 100644 index 0000000..f31c66e --- /dev/null +++ b/plugins/DX8/src/java/net/java/games/input/DirectInputDevice.java @@ -0,0 +1,207 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ +/***************************************************************************** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materails provided with the distribution. + * + * Neither the name Sun Microsystems, Inc. or the names of the contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND + * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS + * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST + * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, + * INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY + * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for us in + * the design, construction, operation or maintenance of any nuclear facility + * + *****************************************************************************/ +package net.java.games.input; + +import net.java.games.input.AbstractController; +import net.java.games.input.Axis; +import net.java.games.input.Controller; +import java.util.ArrayList; +import java.util.Iterator; + +/** + * + * @author martak + * @version + */ +class DirectInputDevice extends AbstractController { + + /** + * DIDEVTYPE_ constants from dinput.h header file + ** JPK NOTE: This changed in DI8. In general this + * is fragile anda way shoudl be found to tie these mroe directly + * to the header files. + */ + /* Mike's <=DX7 types + private static final int DIDEVTYPEJOYSTICK_UNKNOWN = 1; + private static final int DIDEVTYPEJOYSTICK_TRADITIONAL = 2; + private static final int DIDEVTYPEJOYSTICK_FLIGHTSTICK = 3; + private static final int DIDEVTYPEJOYSTICK_GAMEPAD = 4; + private static final int DIDEVTYPEJOYSTICK_RUDDER = 5; + private static final int DIDEVTYPEJOYSTICK_WHEEL = 6; + private static final int DIDEVTYPEJOYSTICK_HEADTRACKER = 7; + */ + + /** + * Pointer to the IDirectInputDevice for this device + */ + private long lpDevice; + + /** + * Type of device + */ + private Type type; + + /** + * Do we need to poll data? + */ + private boolean polled = true; + /** + * Data when polling, as per the DIJOYSTATE structure in dinput.h; + * @see DirectInputAxis for a breakdown of this structure + */ + int[] data = new int[32]; + + /** + * Private constructor + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of device, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the device + * @param instanceName The name of the device + */ + private DirectInputDevice(long lpDevice, int subtype, String productName, + String instanceName,boolean polled) { + super(productName + " " + instanceName); + this.lpDevice = lpDevice; + this.polled = polled; + System.out.println("Creating "+productName+" polling = "+polled); + switch(subtype) { + /* + case DIDEVTYPEJOYSTICK_GAMEPAD: + type = Type.GAMEPAD; break; + case DIDEVTYPEJOYSTICK_RUDDER: + type = Type.RUDDER; break; + case DIDEVTYPEJOYSTICK_WHEEL: + type = Type.WHEEL; break; + case DIDEVTYPEJOYSTICK_HEADTRACKER: + type = Type.HEADTRACKER; break; + case DIDEVTYPEJOYSTICK_TRADITIONAL: // fall through + case DIDEVTYPEJOYSTICK_FLIGHTSTICK: // fall through + */ + default: + type = Type.STICK; break; + } + axes = initDirectInputAxes(); + } + + /** + * Used instead of overriding initAxes because it needs the + * pointer to the IDirectInputDevice + */ + private Axis[] initDirectInputAxes() { + ArrayList list = new ArrayList(); + enumObjects(lpDevice, list); + Axis[] ret = new Axis[list.size()]; + Iterator it = list.iterator(); + int i = 0; + while (it.hasNext()) { + ret[i] = (Axis)it.next(); + i++; + } + return ret; + } + + /** + * Callback called by enumObjects to add a new axis into the list + * @param list This in which to add the new axis + * @param id The identifier for the axis, based on GUID + * @param didft The combination of DIDFT_ flags that make up the type and + * instance number of the axis. + * @param name The name to call the axis. + */ + private void addAxis(ArrayList list, Axis.Identifier id, int didft, + String name) { + list.add(DirectInputAxis.createAxis(this, id, didft, name)); + } + + /** Polls axes for data. Returns false if the controller is no longer valid. + * Polling reflects the current state of the device when polled, and is + * unbuffered. + * @return False if the co troller is no longer valid, else true. + */ + public boolean poll() { + return pollNative(lpDevice, data, polled); + } + + /** Returns the type of Controller. + * @return The type of the controller. + */ + public Type getType() { + return type; + } + + /** Returns the zero-based port number for this Controller. + * @return The port number. + */ + public int getPortNumber() { + // REMIND : We may be able to parse this from the name string + return 0; + } + + /** + * Polls the device; native method. The data from the poll is stored in + * the data array. + */ + private native boolean pollNative(long lpDevice, int[] data, + boolean polled); + + /** + * Enumerates the axes on the device + */ + private native boolean enumObjects(long lpDevice, ArrayList list); + + /** Creates a new DirectInputDevice (factory method) + * This is a function used internally during set up + * @param polled Whether this device's driver should actually be + * polled during a call to Poll or whether it is an + * interrupt driven device that should ignore poll + * requests. + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of device, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the device + * @param instanceName The name of the device + * @return The new DirectInputDevice object + */ + public static DirectInputDevice createDevice(long lpDevice, int subtype, + String productName, String instanceName, boolean polled) { + return new DirectInputDevice(lpDevice, subtype, productName, + instanceName,polled); + } +} // class DirectInputDevice diff --git a/plugins/DX8/src/java/net/java/games/input/DirectInputEnvironmentPlugin.java b/plugins/DX8/src/java/net/java/games/input/DirectInputEnvironmentPlugin.java new file mode 100644 index 0000000..a406b09 --- /dev/null +++ b/plugins/DX8/src/java/net/java/games/input/DirectInputEnvironmentPlugin.java @@ -0,0 +1,183 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ +/***************************************************************************** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materails provided with the distribution. + * + * Neither the name Sun Microsystems, Inc. or the names of the contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND + * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS + * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST + * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, + * INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY + * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for us in + * the design, construction, operation or maintenance of any nuclear facility + * + *****************************************************************************/ +package net.java.games.input; + +import java.security.AccessController; +import java.util.ArrayList; +import java.util.Iterator; +import net.java.games.input.Controller; +import net.java.games.input.ControllerEnvironment; +//import sun.security.action.LoadLibraryAction; +import net.java.games.util.plugins.Plugin; + +/** DirectInput implementation of controller environment + * @author martak + * @version 1.0 + */ +public class DirectInputEnvironmentPlugin extends ControllerEnvironment + implements Plugin +{ + + static { + /** Mikes old code, causes it to be laoded by wrong loader + java.security.AccessController.doPrivileged( + new LoadLibraryAction("jinput")); + */ + System.loadLibrary("dxinput"); + } + + /** + * DIDEVTYPE_ constants from dinput.h header file + * JPK NOTE: changed in DX8 so had to be changed. This is + * fragile, we should find a way to set them from + * the C side sowe can stay up to date with header + */ + /** DX7 and earlier + private static final int DIDEVTYPE_DEVICE = 1; + private static final int DIDEVTYPE_MOUSE = 2; + private static final int DIDEVTYPE_KEYBOARD = 3; + private static final int DIDEVTYPE_JOYSTICK = 4; + private static final int DIDEVTYPE_HID = 0x00010000; + private static int GET_DIDEVICE_TYPE(int dwDevType) { + return (int)((byte)dwDevType); + } + private static int GET_DIDEVICE_SUBTYPE(int dwDevType) { + return (int)((byte)((((short)dwDevType) >> 8) & 0xFF)); + } + **/ + /* DX8 and 9 */ + private static final int DI8DEVTYPE_DEVICE = 0x11; + private static final int DI8DEVTYPE_MOUSE = 0x12; + private static final int DI8DEVTYPE_KEYBOARD = 0x13; + private static final int DI8DEVTYPE_JOYSTICK = 0x14; + private static final int DI8DEVTYPE_GAMEPAD = 0x15; + private static final int DI8DEVTYPE_DRIVING = 0x16; + private static final int DI8DEVTYPE_FLIGHT = 0x17; + private static final int DI8DEVTYPE_1STPERSON = 0x18; + private static final int DI8DEVTYPE_DEVICECTRL = 0x19; + private static final int DI8DEVTYPE_SCREENPOINTER = 0x1A; + private static final int DI8DEVTYPE_REMOTE = 0x1B; + private static final int DI8DEVTYPE_SUPPLEMENTAL = 0x1C; + + private static int GET_DIDEVICE_TYPE(int dwDevType) { + return (dwDevType&0xFF); + } + private static int GET_DIDEVICE_SUBTYPE(int dwDevType) { + return (int)((byte)((((short)dwDevType) >> 8) & 0xFF)); + } + + // Pointer to DirectInput instance + private long lpDirectInput; + // Permanent array of controllers + private Controller[] controllers; + + /** Creates new DirectInputEnvironment */ + public DirectInputEnvironmentPlugin() { + lpDirectInput = directInputCreate(); + enumControllers(); + } + + /** Returns a list of all controllers available to this environment, + * or an empty array if there are no controllers in this environment. + * @return An array of controllers that may be empty. + */ + public Controller[] getControllers() { + return controllers; + } + + private void enumControllers() { + // If direct input fails, create an empty array + if (lpDirectInput == 0) { + controllers = new Controller[] {}; + return; + } + // Create temporary controller array + ArrayList tempDevices = new ArrayList(); + // Eumerate devices + enumDevices(lpDirectInput, tempDevices); + // Set up permanent controller array + controllers = new Controller[tempDevices.size()]; + Iterator it = tempDevices.iterator(); + int i = 0; + while (it.hasNext()) { + controllers[i] = (Controller)it.next(); + i++; + } + } + + /** + * Creates a new device, adding it to the list supplied. + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param type The type of device to create, as defined by the constants + * in dinput.h (see DI8DEVTYPE constants above). + * @param productName The product name for the device + * @param instanceName The name of the device + */ + private void addDevice(ArrayList list, long lpDevice, + int type, String productName, String instanceName, boolean polled) { + Controller c; + int category = GET_DIDEVICE_TYPE(type); + int subtype = GET_DIDEVICE_SUBTYPE(type); + //System.out.println("Category = "+category); + if (category == DI8DEVTYPE_MOUSE) { + c = DirectInputMouse.createMouse(lpDevice, subtype, productName, + instanceName); + } else if (category == DI8DEVTYPE_KEYBOARD) { + c = DirectInputKeyboard.createKeyboard(lpDevice, subtype, + productName, instanceName); + } else { + assert category == DI8DEVTYPE_JOYSTICK; + c = DirectInputDevice.createDevice(lpDevice, subtype, productName, + instanceName,polled); + } + if (c != null) { + list.add(c); + } + } + + /** + * Returns the direct input instance, or 0 if failed to initialize + */ + private native long directInputCreate(); + + /** + * Enumerates all devices, calling createDevice for each one + */ + private native boolean enumDevices(long lpDirectInput, ArrayList list); +} // class DirectInputEnvironment diff --git a/plugins/DX8/src/java/net/java/games/input/DirectInputKeyboard.java b/plugins/DX8/src/java/net/java/games/input/DirectInputKeyboard.java new file mode 100644 index 0000000..6faf163 --- /dev/null +++ b/plugins/DX8/src/java/net/java/games/input/DirectInputKeyboard.java @@ -0,0 +1,208 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ +/***************************************************************************** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materails provided with the distribution. + * + * Neither the name Sun Microsystems, Inc. or the names of the contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND + * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS + * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST + * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, + * INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY + * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for us in + * the design, construction, operation or maintenance of any nuclear facility + * + *****************************************************************************/ +package net.java.games.input; + +import net.java.games.input.AbstractAxis; +import net.java.games.input.Axis; +import net.java.games.input.StandardKeyboard; + +/** + * DirectInput keyboard implementation. + * @author martak + * @version + */ +class DirectInputKeyboard extends StandardKeyboard { + + /** + * DIDEVTYPE_ constants from dinput.h header file + */ + private static final int DIDEVTYPEKEYBOARD_UNKNOWN = 0; + private static final int DIDEVTYPEKEYBOARD_PCXT = 1; + private static final int DIDEVTYPEKEYBOARD_OLIVETTI = 2; + private static final int DIDEVTYPEKEYBOARD_PCAT = 3; + private static final int DIDEVTYPEKEYBOARD_PCENH = 4; + private static final int DIDEVTYPEKEYBOARD_NOKIA1050 = 5; + private static final int DIDEVTYPEKEYBOARD_NOKIA9140 = 6; + private static final int DIDEVTYPEKEYBOARD_NEC98 = 7; + private static final int DIDEVTYPEKEYBOARD_NEC98LAPTOP = 8; + private static final int DIDEVTYPEKEYBOARD_NEC98106 = 9; + private static final int DIDEVTYPEKEYBOARD_JAPAN106 = 10; + private static final int DIDEVTYPEKEYBOARD_JAPANAX = 11; + private static final int DIDEVTYPEKEYBOARD_J3100 = 12; + + /** + * Key index crosstable; maps indices into the data array to virtual keys + * in the key array in StandardKeyboard. + * For example, the key F11 is at index 84 in the array of keys in + * StandardKeyboard, yet it is data element 87 (0x57) in our data array. + * <p> + * To access the data element of a particular key (F11), we use the + * crosstable as follows: + * <p><code> + * KeyID f11 = StandardKey.KeyID.F11; + * int keyIndex = f11.getKeyIndex(); // returns 84 + * int crossIndex = CROSSTABLE[keyIndex]; // returns 0x57 (87) + * </code> + * To find a key given the data element index (87), we do a simple search + * through the crosstable starting at that index (index 87/0x57 = 0x65) and + * looking backwards until we find our key itself, or a lower number + * (meaning the key was not found). We can only take advantage of this + * algorithm only because on Windows, our crosstable is in increasing order. + */ + private final static int[] CROSSTABLE = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, // _9 + 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, // Y + 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // D + 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, // BACKSLASH + 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, // RSHIFT + 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, // F7 + 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, // NUMPAD5 + 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x57, 0x58, 0x64, 0x65, // F14 + 0x66, 0x70, 0x79, 0x7B, 0x7D, 0x8D, 0x90, 0x91, 0x92, 0x93, 0x94, // KANJI + 0x95, 0x96, 0x97, 0x9C, 0x9D, 0xB3, 0xB5, 0xB7, 0xB8, 0xC5, 0xC7, // HOME + 0xC8, 0xC9, 0xCB, 0xCD, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xDB, 0xDC, // RWIN + 0xDD, 0xDE, 0xDF // SLEEP + }; + + /** + * Pointer to the IDirectInputDevice for this device + */ + private long lpDevice; + + /** + * Subtype of keyboard, defined by DIDEVTYPE constants + */ + private int subtype; + + /** + * Polling key data + */ + private byte[] keyData = new byte[256]; + + /** + * Private constructor + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of keyboard, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the device + * @param instanceName The name of the device + */ + private DirectInputKeyboard(long lpDevice, int subtype, String productName, + String instanceName) { + super(productName + " (" + instanceName + ")"); + this.lpDevice = lpDevice; + this.subtype = subtype; + } + + /** + * Callback to rename a given key by index, name + * @param index the index in the data array + * @param name the name of the key + */ + private void renameKey(int index, String name) { + int keyIndex = index; + if (keyIndex > CROSSTABLE.length) { + keyIndex = CROSSTABLE.length - 1; + } + for (; CROSSTABLE[keyIndex] > index; keyIndex--) + ; + if (CROSSTABLE[keyIndex] == index) { + Axis[] axes = getAxes(); + AbstractAxis key = (AbstractAxis)axes[index]; + if (name != null && name.length() > 0) { + //System.out.println("Renaming key " + key.getName() + + // " to " + name + " index=" + + // index + " keyIndex=" + keyIndex + " CROSSTAB=" + + // CROSSTABLE[keyIndex]); + key.setName(name); + } + } else { + //System.out.println("Key not found " + name + " index=" + index + + // " keyIndex=" + keyIndex + " CROSSTAB=" + + // CROSSTABLE[keyIndex]); + } + } + + /** Polls axes for data. Returns false if the controller is no longer valid. + * Polling reflects the current state of the device when polled. + * @return False if the KB is no longer valid, true otherwise. + */ + public boolean poll() { + return pollNative(lpDevice, keyData); + } + + /** Returns whether or not the given key has been pressed since the last + * call to poll. + * @param key The key whose state to check. + * @return true if this key has changed state since last read of its state, false otherwise. + */ + protected boolean isKeyPressed(Key key) { + KeyID id = (KeyID)key.getIdentifier(); + int keyIndex = id.getKeyIndex(); + int crossIndex = CROSSTABLE[keyIndex]; + return ((keyData[crossIndex] & 0x80) != 0); + } + + /** + * Polls the device; native method + */ + private native boolean pollNative(long lpDevice, byte[] keyData); + + /** + * Renames the keys with the name provided by DirectInput + */ + private native boolean renameKeys(long lpDevice); + + /** Creates a new DirectInputKeyboard (factory method) + * This is a function used internally during set up. + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of keyboard, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the keyboard + * @param instanceName The name of the keyboard + * @return The new DirectInputKeyboard object. + */ + public static DirectInputKeyboard createKeyboard(long lpDevice, + int subtype, String productName, String instanceName) { + DirectInputKeyboard ret = new DirectInputKeyboard(lpDevice, subtype, + productName, instanceName); + ret.renameKeys(lpDevice); + return ret; + } +} // class DirectInputKeyboard diff --git a/plugins/DX8/src/java/net/java/games/input/DirectInputMouse.java b/plugins/DX8/src/java/net/java/games/input/DirectInputMouse.java new file mode 100644 index 0000000..f706250 --- /dev/null +++ b/plugins/DX8/src/java/net/java/games/input/DirectInputMouse.java @@ -0,0 +1,311 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ +/***************************************************************************** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materails provided with the distribution. + * + * Neither the name Sun Microsystems, Inc. or the names of the contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND + * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS + * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST + * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, + * INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY + * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for us in + * the design, construction, operation or maintenance of any nuclear facility + * + *****************************************************************************/ +package net.java.games.input; + +import net.java.games.input.AbstractAxis; +import net.java.games.input.Axis; +import net.java.games.input.Mouse; + +/** + * DirectInput mouse implementation. + * @author martak + * @version + */ +class DirectInputMouse extends Mouse { + + /** + * DIDEVTYPE_ constants from dinput.h header file + */ + private static final int DIDEVTYPEMOUSE_UNKNOWN = 1; + private static final int DIDEVTYPEMOUSE_TRADITIONAL = 2; + private static final int DIDEVTYPEMOUSE_FINGERSTICK = 3; + private static final int DIDEVTYPEMOUSE_TOUCHPAD = 4; + private static final int DIDEVTYPEMOUSE_TRACKBALL = 5; + + /** + * Pointer to the IDirectInputDevice for this device + */ + private long lpDevice; + + /** + * Type of mouse + */ + private Type type; + + /** + * Mouse data + */ + private byte[] mouseData = new byte[16]; + + /** + * Private constructor + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of mouse, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the device + * @param instanceName The name of the device + */ + private DirectInputMouse(long lpDevice, int subtype, String productName, + String instanceName) { + super(productName + " " + instanceName); + buttons = new ButtonsImpl(); + ball = new BallImpl(); + this.lpDevice = lpDevice; + switch(subtype) { + case DIDEVTYPEMOUSE_FINGERSTICK: + type = Type.FINGERSTICK; break; + case DIDEVTYPEMOUSE_TOUCHPAD: + type = Type.TRACKPAD; break; + case DIDEVTYPEMOUSE_TRACKBALL: + type = Type.TRACKBALL; break; + case DIDEVTYPEMOUSE_TRADITIONAL: // fall through + case DIDEVTYPEMOUSE_UNKNOWN: // fall through + default: + type = Type.MOUSE; break; + } + renameAxes(lpDevice); + } + + /** + * Callback to rename a given axis by type, name + */ + private void renameAxis(Axis.Identifier id, String name) { + AbstractAxis axis; + if (id instanceof ButtonID) { + axis = (AbstractAxis)getButtons().getAxis(id); + } else { + axis = (AbstractAxis)getBall().getAxis(id); + } + axis.setName(name); + //System.out.println("Renaming " + name); + } + + /** Polls axes for data. Returns false if the controller is no longer valid. + * Polling reflects the current state of the device when polled. + * @return false if the mosue is no lonegr valid, true otherwise. + */ + public boolean poll() { + return pollNative(lpDevice, mouseData); + } + + /** Returns the type of the Controller. + * @return The device type of the controller (logically this + * shoudl be some form of "mouse" .) + */ + public Type getType() { + return type; + } + + /** Creates a new DirectInputMouse (factory method) + * This is a function used internally during set up. + * @param lpDevice A pointer to the IDirectInputDevice for the device. + * @param subtype The subtype of mouse, as defined in the DIDEVTYPE + * constants above + * @param productName The product name for the keyboard + * @param instanceName The name of the keyboard + * @return The new DirectInputMouse object. + */ + public static DirectInputMouse createMouse(long lpDevice, int subtype, + String productName, String instanceName) { + return new DirectInputMouse(lpDevice, subtype, productName, + instanceName); + } + + /** + * Implementation class representing the mouse ball + */ + class BallImpl extends Ball { + + /** + * Public constructor + */ + public BallImpl() { + super(DirectInputMouse.this.getName() + " ball"); + x = new BallAxis(Axis.Identifier.X); + y = new BallAxis(Axis.Identifier.Y); + wheel = new BallAxis(Axis.Identifier.SLIDER); + } + } // class DirectInputMouse.BallImpl + + /** + * Implementation class representing the mouse buttons + */ + class ButtonsImpl extends Buttons { + + /** + * Public constructor + */ + public ButtonsImpl() { + super(DirectInputMouse.this.getName() + " buttons"); + left = new ButtonImpl(ButtonID.LEFT); + right = new ButtonImpl(ButtonID.RIGHT); + middle = new ButtonImpl(ButtonID.MIDDLE); + } + } // class DirectInputMouse.ButtonsImpl + + /** + * Polls the device; native method + */ + private native boolean pollNative(long lpDevice, byte[] mouseData); + + /** + * Renames the axes with the name provided by DirectInput + */ + private native boolean renameAxes(long lpDevice); + + /** + * Mouse button axis implementation + */ + class ButtonImpl extends Button { + + /** + * Index into the mouseData array + */ + private final int index; + + /** Public constructor + * @param id An ID of a button to create an obejct to represent. + * + */ + public ButtonImpl(ButtonID id) { + super(id.getName(), id); + if (id == ButtonID.LEFT) { + index = 12; + } else if (id == ButtonID.RIGHT) { + index = 13; + } else if (id == ButtonID.MIDDLE) { + index = 14; + } else { + throw new RuntimeException("Unknown button"); + } + } + + /** Returns the data from the last time the control has been polled. + * If this axis is a button, the value returned will be either 0.0f or 1.0f. + * If this axis is normalized, the value returned will be between -1.0f and + * 1.0f. + * @return state of controller. (Note: DX8 mice actually + * queue state so what is returned is the next state, + * not necessarily the most current one.) + */ + public float getPollData() { + // Mouse button + byte data = mouseData[index]; + if ((data & 0x80) != 0) { + return 1.0f; + } else { + return 0.0f; + } + } + + /** Returns <code>true</code> if data returned from <code>poll</code> + * is relative to the last call, or <code>false</code> if data + * is absolute. + * @return true if data is relative, otherwise false. + */ + public boolean isRelative() { + return false; + } + } // class DirectInputMouse.ButtonImpl + + /** + * Mouse ball axis implementation + */ + class BallAxis extends AbstractAxis { + + /** + * Starting index into the mouseData array + */ + private final int index; + + /** Public constructor + * @param id An ID for a mouse axis to create an object to represent. + */ + public BallAxis(Identifier id) { + super(id.getName(), id); + if (id == Identifier.X) { + index = 0; + } else if (id == Identifier.Y) { + index = 4; + } else if (id == Identifier.SLIDER) { + index = 8; + } else { + throw new RuntimeException("Unknown mouse axis"); + } + } + + /** Returns the data from the last time the control has been polled. + * If this axis is a button, the value returned will be either 0.0f or 1.0f. + * If this axis is normalized, the value returned will be between -1.0f and + * 1.0f. + * @return data. (Note that mice queue state in DX8 so what + * is returned is the next stae in the queue, not + * necessarily the most current one.) + */ + public float getPollData() { + int data = ((int)mouseData[index] << 12) | + ((int)mouseData[index + 1] << 8) | + ((int)mouseData[index + 2] << 4) | + ((int)mouseData[index + 3]); + if (data == -1) { + return -1.0f; + } else if (data >= 1) { + return 1.0f; + } else { + return 0.0f; + } + } + + /** Returns <code>true</code> if data returned from <code>poll</code> + * is relative to the last call, or <code>false</code> if data + * is absolute. + * @return true if relative, otherwise false. + */ + public boolean isRelative() { + return true; + } + + /** Returns whether or not the axis is analog, or false if it is digital. + * @return true if analog, false if digital + */ + public boolean isAnalog() { + return true; + } + } // class DirectInputMouse.MouseBallAxis +} // class DirectInputMouse diff --git a/plugins/DX8/src/native/input.cpp b/plugins/DX8/src/native/input.cpp new file mode 100644 index 0000000..ccfda2f --- /dev/null +++ b/plugins/DX8/src/native/input.cpp @@ -0,0 +1,888 @@ +/* + * %W% %E% + * + * Copyright 2002 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ + +#ifndef WIN32 + #error This is a Windows-only file +#endif + +// hard define as DX7 +//#define DIRECTINPUT_VERSION 0x0800 +#include <windows.h> +#include <jni.h> +#include <dinput.h> + + +/* + ****************************************************************************** + * Global variables + ****************************************************************************** + */ +jclass CLASS_AxisIdentifier = NULL; +jclass CLASS_ButtonIdentifier = NULL; +jclass CLASS_DirectInputEnvironmentPlugin = NULL; +jclass CLASS_DirectInputDevice = NULL; +jclass CLASS_DirectInputKeyboard = NULL; +jclass CLASS_DirectInputMouse = NULL; +jmethodID MID_AddDevice = NULL; +jmethodID MID_AddAxis = NULL; +jmethodID MID_RenameKey = NULL; +jmethodID MID_RenameAxis = NULL; +jfieldID FID_X = NULL; +jfieldID FID_Y = NULL; +jfieldID FID_Z = NULL; +jfieldID FID_RX = NULL; +jfieldID FID_RY = NULL; +jfieldID FID_RZ = NULL; +jfieldID FID_Slider = NULL; +jfieldID FID_Button = NULL; +jfieldID FID_POV = NULL; +jfieldID FID_Left = NULL; +jfieldID FID_Right = NULL; +jfieldID FID_Middle = NULL; + +const char* FD_AxisIdentifier = "Lnet/java/games/input/Axis$Identifier;"; +const char* FD_ButtonIdentifier = "Lnet/java/games/input/Mouse$ButtonID;"; +// Dummy input window. This is needed because DirectX evidently needs a window +// to do anything, such as setting the cooperative level for a device. +const TCHAR* DUMMY_WINDOW_NAME = "InputControllerWindow"; +HWND hwndDummy = NULL; +// Buffer size +const DWORD BUFFER_SIZE = 16; + +// Class for handing device data to the callback for EnumDevices +class DeviceParamData { +public: + DeviceParamData(LPDIRECTINPUT8 lpdi, JNIEnv* e, jobject o, jobject l) : + lpDirectInput(lpdi), env(e), obj(o), list(l) + { + } + LPDIRECTINPUT8 lpDirectInput; + JNIEnv* env; + jobject obj; + jobject list; +}; + +// Class for handing device data to the callback for EnumObjects +class ObjectParamData { +public: + ObjectParamData(LPDIRECTINPUTDEVICE8 lpDev, JNIEnv* e, jobject o, + jobject l) : + lpDevice(lpDev), env(e), obj(o), list(l) + { + } + LPDIRECTINPUTDEVICE8 lpDevice; + JNIEnv* env; + jobject obj; + jobject list; +}; + +void PrintOutput(TCHAR* tszMessage) { + printf("%s\n", tszMessage); +} + +void PrintDIError(TCHAR* tszOutput, HRESULT res) { + TCHAR tszMessage[256]; +#define CHECK_RESULT(r) case r: \ +sprintf(tszMessage, "%s : %s", tszOutput, #r); \ +break; + switch (res) { + CHECK_RESULT(DI_OK) + CHECK_RESULT(DI_NOTATTACHED) + CHECK_RESULT(DI_POLLEDDEVICE) + CHECK_RESULT(DI_DOWNLOADSKIPPED) + CHECK_RESULT(DI_EFFECTRESTARTED) + CHECK_RESULT(DI_TRUNCATED) + CHECK_RESULT(DI_TRUNCATEDANDRESTARTED) + CHECK_RESULT(DIERR_OLDDIRECTINPUTVERSION) + CHECK_RESULT(DIERR_BETADIRECTINPUTVERSION) + CHECK_RESULT(DIERR_BADDRIVERVER) + CHECK_RESULT(DIERR_DEVICENOTREG) + CHECK_RESULT(DIERR_NOTFOUND) + //CHECK_RESULT(DIERR_OBJECTNOTFOUND) + CHECK_RESULT(DIERR_INVALIDPARAM) + CHECK_RESULT(DIERR_NOINTERFACE) + CHECK_RESULT(DIERR_GENERIC) + CHECK_RESULT(DIERR_OUTOFMEMORY) + CHECK_RESULT(DIERR_UNSUPPORTED) + CHECK_RESULT(DIERR_NOTINITIALIZED) + CHECK_RESULT(DIERR_ALREADYINITIALIZED) + CHECK_RESULT(DIERR_NOAGGREGATION) + CHECK_RESULT(DIERR_OTHERAPPHASPRIO) + CHECK_RESULT(DIERR_INPUTLOST) + CHECK_RESULT(DIERR_ACQUIRED) + CHECK_RESULT(DIERR_NOTACQUIRED) + //CHECK_RESULT(DIERR_READONLY) + //CHECK_RESULT(DIERR_HANDLEEXISTS) + CHECK_RESULT(DIERR_INSUFFICIENTPRIVS) + CHECK_RESULT(DIERR_DEVICEFULL) + CHECK_RESULT(DIERR_MOREDATA) + CHECK_RESULT(DIERR_NOTDOWNLOADED) + CHECK_RESULT(DIERR_HASEFFECTS) + CHECK_RESULT(DIERR_NOTEXCLUSIVEACQUIRED) + CHECK_RESULT(DIERR_INCOMPLETEEFFECT) + CHECK_RESULT(DIERR_NOTBUFFERED) + CHECK_RESULT(DIERR_EFFECTPLAYING) + CHECK_RESULT(DIERR_UNPLUGGED) + CHECK_RESULT(DIERR_REPORTFULL) + default: sprintf(tszMessage, "Unknown"); break; + } + PrintOutput(tszMessage); +} + +/* + ****************************************************************************** + * DirectInputEnvironmentPlugin + ****************************************************************************** + */ + +/* + * Initialize all class, method, and field IDs + */ +BOOL InitIDs(JNIEnv* env) { + CLASS_AxisIdentifier = + env->FindClass("net/java/games/input/Axis$Identifier"); + if (CLASS_AxisIdentifier == NULL) { + return FALSE; + } + FID_X = env->GetStaticFieldID(CLASS_AxisIdentifier, "X", + FD_AxisIdentifier); + if (FID_X == NULL) { + return FALSE; + } + FID_Y = env->GetStaticFieldID(CLASS_AxisIdentifier, "Y", + FD_AxisIdentifier); + if (FID_Y == NULL) { + return FALSE; + } + FID_Z = env->GetStaticFieldID(CLASS_AxisIdentifier, "Z", + FD_AxisIdentifier); + if (FID_Z == NULL) { + return FALSE; + } + FID_RX = env->GetStaticFieldID(CLASS_AxisIdentifier, "RX", + FD_AxisIdentifier); + if (FID_RX == NULL) { + return FALSE; + } + FID_RY = env->GetStaticFieldID(CLASS_AxisIdentifier, "RY", + FD_AxisIdentifier); + if (FID_RY == NULL) { + return FALSE; + } + FID_RZ = env->GetStaticFieldID(CLASS_AxisIdentifier, "RZ", + FD_AxisIdentifier); + if (FID_RZ == NULL) { + return FALSE; + } + FID_Slider = env->GetStaticFieldID(CLASS_AxisIdentifier, "SLIDER", + FD_AxisIdentifier); + if (FID_Slider == NULL) { + return FALSE; + } + FID_Button = env->GetStaticFieldID(CLASS_AxisIdentifier, "BUTTON", + FD_AxisIdentifier); + if (FID_Button == NULL) { + return FALSE; + } + FID_POV = env->GetStaticFieldID(CLASS_AxisIdentifier, "POV", + FD_AxisIdentifier); + if (FID_POV == NULL) { + return FALSE; + } + CLASS_ButtonIdentifier = + env->FindClass("net/java/games/input/Mouse$ButtonID"); + if (CLASS_ButtonIdentifier == NULL) { + return FALSE; + } + FID_Left = env->GetStaticFieldID(CLASS_ButtonIdentifier, "LEFT", + FD_ButtonIdentifier); + if (FID_Left == NULL) { + return FALSE; + } + FID_Right = env->GetStaticFieldID(CLASS_ButtonIdentifier, "RIGHT", + FD_ButtonIdentifier); + if (FID_Right == NULL) { + return FALSE; + } + FID_Middle = env->GetStaticFieldID(CLASS_ButtonIdentifier, "MIDDLE", + FD_ButtonIdentifier); + if (FID_Middle == NULL) { + return FALSE; + } + CLASS_DirectInputEnvironmentPlugin = + env->FindClass("net/java/games/input/DirectInputEnvironmentPlugin"); + if (CLASS_DirectInputEnvironmentPlugin == NULL) { + return FALSE; + } + MID_AddDevice = env->GetMethodID(CLASS_DirectInputEnvironmentPlugin, "addDevice", + "(Ljava/util/ArrayList;JILjava/lang/String;Ljava/lang/String;Z)V"); + if (MID_AddDevice == NULL) { + return FALSE; + } + CLASS_DirectInputDevice = + env->FindClass("net/java/games/input/DirectInputDevice"); + if (CLASS_DirectInputDevice == NULL) { + return FALSE; + } + MID_AddAxis = env->GetMethodID(CLASS_DirectInputDevice, "addAxis", + "(Ljava/util/ArrayList;Lnet/java/games/input/Axis$Identifier;ILjava/lang/String;)V"); + if (MID_AddAxis == NULL) { + return FALSE; + } + CLASS_DirectInputKeyboard = + env->FindClass("net/java/games/input/DirectInputKeyboard"); + if (CLASS_DirectInputKeyboard == NULL) { + return FALSE; + } + MID_RenameKey = env->GetMethodID(CLASS_DirectInputKeyboard, "renameKey", + "(ILjava/lang/String;)V"); + if (MID_RenameKey == NULL) { + return FALSE; + } + CLASS_DirectInputMouse = + env->FindClass("net/java/games/input/DirectInputMouse"); + if (CLASS_DirectInputMouse == NULL) { + return FALSE; + } + MID_RenameAxis = env->GetMethodID(CLASS_DirectInputMouse, "renameAxis", + "(Lnet/java/games/input/Axis$Identifier;Ljava/lang/String;)V"); + if (MID_RenameAxis == NULL) { + return FALSE; + } + return TRUE; +} + +/* + * WndProc for our dummy input window + */ +LRESULT CALLBACK DummyWndProc( + HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + return DefWindowProc(hWnd, message, wParam, lParam); +} + +/* + * Register the dummy input window class + */ +BOOL RegisterDummyWindow(HINSTANCE hInstance) +{ + WNDCLASSEX wcex; + wcex.cbSize = sizeof(WNDCLASSEX); + wcex.style = CS_HREDRAW | CS_VREDRAW; + wcex.lpfnWndProc = (WNDPROC)DummyWndProc; + wcex.cbClsExtra = 0; + wcex.cbWndExtra = 0; + wcex.hInstance = hInstance; + wcex.hIcon = NULL; + wcex.hCursor = NULL; + wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); + wcex.lpszMenuName = (LPCSTR)NULL; + wcex.lpszClassName = DUMMY_WINDOW_NAME; + wcex.hIconSm = NULL; + return RegisterClassEx(&wcex); +} + +/* + * Class: org_java_games_input_DirectInputEnvironmentPlugin + * Method: directInputCreate + * Signature: ()J + */ +extern "C" JNIEXPORT jlong JNICALL +Java_net_java_games_input_DirectInputEnvironmentPlugin_directInputCreate + (JNIEnv* env, jobject obj) +{ + // Get our module handle + HINSTANCE hInst = GetModuleHandle(NULL); + + // Register the dummy input window + if (!RegisterDummyWindow(hInst)) { + return (jlong)0; + } + + // Create the dummy input window + hwndDummy = CreateWindow(DUMMY_WINDOW_NAME, NULL, + WS_POPUP | WS_ICONIC, + 0, 0, 0, 0, NULL, NULL, hInst, NULL); + if (hwndDummy == NULL) + { + return (jlong)0; + } + + // Create the IDirectInput object + DWORD dwVersion = DIRECTINPUT_VERSION; + LPDIRECTINPUT8 lpDirectInput = NULL; + HRESULT res; + if (FAILED(res = DirectInput8Create(hInst, DIRECTINPUT_VERSION, + IID_IDirectInput8,(VOID **)&lpDirectInput, NULL))){ + PrintDIError("DirectInputCreate", res); + return (jlong)0; + } + + // Initialize method, class, and field IDs + if (!InitIDs(env)) { + lpDirectInput->Release(); + return (jlong)0; + } + + return (jlong)(long)lpDirectInput; +} + +/* + * Enumeration callback for devices + * + * returns DIENUM_CONTINUE or DIENUM_STOP + */ + +/** mikes old enum callback +BOOL CALLBACK EnumDeviceCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef) +{ + DeviceParamData* pData = (DeviceParamData*)pvRef; + LPDIRECTINPUT8 lpDirectInput = pData->lpDirectInput; + JNIEnv* env = pData->env; + jobject obj = pData->obj; + jobject list = pData->list; + LPDIRECTINPUTDEVICE8 lpDevice = NULL; + LPUNKNOWN pUnknown = NULL; + + // Create the device object + HRESULT res = lpDirectInput->CreateDevice(lpddi->guidInstance, &lpDevice, + pUnknown); + if (res != DI_OK) { + PrintDIError("CreateDevice", res); + return DIENUM_STOP; + } + + LPDIRECTINPUTDEVICE8 lpDevice2 = NULL; + // Get the IDirectDrawDevice8 interface from the object + res = lpDevice->QueryInterface(IID_IDirectInputDevice8, + (void**)&lpDevice2); + if (res != DI_OK) { + PrintDIError("QueryInterface DID2", res); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Set the data format + DWORD category = GET_DIDEVICE_TYPE(lpddi->dwDevType); + LPCDIDATAFORMAT lpDataFormat = &c_dfDIJoystick; + if (category == DI8DEVTYPE_MOUSE) { + lpDataFormat = &c_dfDIMouse; + } else if (category == DI8DEVTYPE_KEYBOARD) { + lpDataFormat = &c_dfDIKeyboard; + } + res = lpDevice2->SetDataFormat(lpDataFormat); + if (res != DI_OK) { + PrintDIError("SetDataFormat", res); + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + + // If we are the mouse, we have to buffer the data + if (category == DI8DEVTYPE_MOUSE) { + DIPROPDWORD dipropdw; + dipropdw.diph.dwSize = sizeof(DIPROPDWORD); + dipropdw.diph.dwHeaderSize = sizeof(DIPROPHEADER); + dipropdw.diph.dwObj = 0; + dipropdw.diph.dwHow = DIPH_DEVICE; + dipropdw.dwData = BUFFER_SIZE; + res = lpDevice2->SetProperty(DIPROP_BUFFERSIZE, &dipropdw.diph); + if (res != DI_OK) { + PrintDIError("SetProperty", res); + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + } + + // Set the cooperative level + res = lpDevice2->SetCooperativeLevel(hwndDummy, + DISCL_NONEXCLUSIVE | DISCL_BACKGROUND); + if (res != DI_OK) { + PrintDIError("SetCooperativeLevel", res); + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Acquire the device + res = lpDevice2->Acquire(); + if (res != DI_OK && res != S_FALSE) { + PrintDIError("Acquire", res); + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Set the variables for the Java callback + jint type = (jint)lpddi->dwDevType; + jstring productName = env->NewStringUTF(lpddi->tszProductName); + if (productName == NULL) { + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + jstring instanceName = env->NewStringUTF(lpddi->tszInstanceName); + if (instanceName == NULL) { + lpDevice2->Release(); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Add the device into the list + env->CallVoidMethod(obj, MID_AddDevice, list, (jlong)(long)lpDevice2, type, + productName, instanceName); + return DIENUM_CONTINUE; +} +*/ +/** jeff's new enum callback */ +BOOL CALLBACK EnumDeviceCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef) +{ + DeviceParamData* pData = (DeviceParamData*)pvRef; + LPDIRECTINPUT8 lpDirectInput = pData->lpDirectInput; + JNIEnv* env = pData->env; + jobject obj = pData->obj; + jobject list = pData->list; + LPDIRECTINPUTDEVICE8 lpDevice = NULL; + LPUNKNOWN pUnknown = NULL; + HRESULT res; + + // Create the device object + if (FAILED(res = lpDirectInput->CreateDevice(lpddi->guidInstance, &lpDevice, + pUnknown))){ + PrintDIError("CreateDevice", res); + return DIENUM_STOP; + } + + /* + LPDIRECTINPUTDEVICE8 lpDevice2 = NULL; + // Get the IDirectDrawDevice8 interface from the object + res = lpDevice->QueryInterface(IID_IDirectInputDevice8, + (void**)&lpDevice2); + if (res != DI_OK) { + PrintDIError("QueryInterface DID2", res); + lpDevice->Release(); + return DIENUM_STOP; + } + */ + + // Set the data format + LPCDIDATAFORMAT lpDataFormat; + DWORD category = GET_DIDEVICE_TYPE(lpddi->dwDevType)&0xFF; + switch (category){ + case DI8DEVTYPE_KEYBOARD: + //printf("found Keyboard\n"); + lpDataFormat = &c_dfDIKeyboard; + break; + case DI8DEVTYPE_MOUSE: + //printf("found mouse\n"); + lpDataFormat = &c_dfDIMouse; + // set up buffering + DIPROPDWORD dipropdw; + dipropdw.diph.dwSize = sizeof(DIPROPDWORD); + dipropdw.diph.dwHeaderSize = sizeof(DIPROPHEADER); + dipropdw.diph.dwObj = 0; + dipropdw.diph.dwHow = DIPH_DEVICE; + dipropdw.dwData = BUFFER_SIZE; + if (FAILED( + res = lpDevice->SetProperty(DIPROP_BUFFERSIZE, + &dipropdw.diph))) { + PrintDIError("SetProperty", res); + lpDevice->Release(); + return DIENUM_STOP; + } + break; + case DI8DEVTYPE_JOYSTICK: + default: + //printf("found stick\n"); + lpDataFormat = &c_dfDIJoystick; + break; + } + + if (FAILED(res = lpDevice->SetDataFormat(lpDataFormat))){ + PrintDIError("SetDataFormat", res); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Set the cooperative level + if(FAILED(res = lpDevice->SetCooperativeLevel(hwndDummy, + DISCL_NONEXCLUSIVE | DISCL_BACKGROUND))){ + PrintDIError("SetCooperativeLevel", res); + lpDevice->Release(); + return DIENUM_STOP; + } + + // get polling + DIDEVCAPS didc; + // Allocate space for all the device's objects (axes, buttons, POVS) + ZeroMemory( &didc, sizeof(DIDEVCAPS) ); + didc.dwSize = sizeof(DIDEVCAPS); + if (FAILED(res=lpDevice->GetCapabilities(&didc))){ + PrintDIError("Get Device Capabilities", res); + lpDevice->Release(); + return DIENUM_STOP; + } + jboolean polled = JNI_FALSE; + if ((didc.dwFlags)&DIDC_POLLEDDATAFORMAT) { + polled = JNI_TRUE; + } + + // Acquire the device + if(FAILED(res = lpDevice->Acquire())){ + PrintDIError("Acquire", res); + lpDevice->Release(); + return DIENUM_STOP; + } + + // Set the variables for the Java callback + jint type = (jint)lpddi->dwDevType&0xffff; + //printf("type == %x\n",type); + jstring productName = env->NewStringUTF(lpddi->tszProductName); + if (productName == NULL) { + lpDevice->Release(); + return DIENUM_STOP; + } + jstring instanceName = env->NewStringUTF(lpddi->tszInstanceName); + if (instanceName == NULL) { + lpDevice->Release(); + return DIENUM_STOP; + } + + // Add the device into the list + env->CallVoidMethod(obj, MID_AddDevice, list, (jlong)(long)lpDevice, type, + productName, instanceName,(jboolean)polled); + return DIENUM_CONTINUE; +} + +/* + * Class: org_java_games_input_DirectInputEnvironmentPlugin + * Method: enumDevices + * Signature: (JLjava/util/ArrayList;)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputEnvironmentPlugin_enumDevices + (JNIEnv* env, jobject obj, jlong lDirectInput, jobject list) +{ + LPDIRECTINPUT8 lpDirectInput = (LPDIRECTINPUT8)(long)lDirectInput; + DWORD dwDevType = DI8DEVCLASS_ALL; + DeviceParamData data(lpDirectInput, env, obj, list); + LPVOID pvRef = (LPVOID)&data; + DWORD dwFlags = DIEDFL_ATTACHEDONLY; + HRESULT res; + if(FAILED(res=lpDirectInput->EnumDevices(dwDevType, + EnumDeviceCallback, pvRef, dwFlags))){ + PrintDIError("EnumDevices", res); + return JNI_FALSE; + } + return JNI_TRUE; +} + +/* + ****************************************************************************** + * DirectInputDevice + ****************************************************************************** + */ + +/* + * Class: org_java_games_input_DirectInputDevice + * Method: pollNative + * Signature: (J[B)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputDevice_pollNative + (JNIEnv* env, jobject obj, jlong lDevice, jintArray baData, + jboolean pollme) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + // Reacquire the device + HRESULT res = lpDevice->Acquire(); + if (res != DI_OK && res != S_FALSE) { + PrintDIError("Acquire", res); + return JNI_FALSE; + } + // Poll the device + if (pollme == JNI_TRUE) { + res = lpDevice->Poll(); + if (res != DI_OK) { + PrintDIError("Poll", res); + return JNI_FALSE; + } + } + // Get the device state (data) + DIJOYSTATE data; + res = lpDevice->GetDeviceState(sizeof(data), &data); + if (res != DI_OK) { + PrintDIError("GetDeviceState", res); + return JNI_FALSE; + } + // Copy the data into the byte array + env->SetIntArrayRegion(baData, 0, (jsize)(sizeof(data)/4), (jint*)&data); + return JNI_TRUE; +} + +/* + * Enumeration callback for device objects + * + * returns DIENUM_CONTINUE or DIENUM_STOP + */ +BOOL CALLBACK EnumObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, + LPVOID pvRef) +{ + ObjectParamData* pData = (ObjectParamData*)pvRef; + LPDIRECTINPUTDEVICE8 lpDevice = pData->lpDevice; + JNIEnv* env = pData->env; + jobject obj = pData->obj; + jobject list = pData->list; + jobject identifier = NULL; + HRESULT res; + if (lpddoi->guidType == GUID_XAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_X); + } else if (lpddoi->guidType == GUID_YAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_Y); + } else if (lpddoi->guidType == GUID_ZAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_Z); + } else if (lpddoi->guidType == GUID_RxAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_RX); + } else if (lpddoi->guidType == GUID_RyAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_RY); + } else if (lpddoi->guidType == GUID_RzAxis) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_RZ); + } else if (lpddoi->guidType == GUID_Slider) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_Slider); + } else if (lpddoi->guidType == GUID_Button) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_Button); + } else if (lpddoi->guidType == GUID_POV) { + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, FID_POV); + } else { + // Do not add this axis into the list, since we don't know what it is + return DIENUM_CONTINUE; + } + if (identifier == NULL) { + return DIENUM_STOP; + } + if (DIDFT_GETTYPE(lpddoi->dwType)&DIDFT_AXIS){ + // set axis range + DIPROPRANGE joy_axis_range; + joy_axis_range.lMin = -32768; + joy_axis_range.lMax = 32768; + joy_axis_range.diph.dwSize=sizeof(DIPROPRANGE); + joy_axis_range.diph.dwHeaderSize=sizeof(DIPROPHEADER); + joy_axis_range.diph.dwHow = DIPH_BYID; + joy_axis_range.diph.dwObj=lpddoi->dwType; + if (FAILED( + res=lpDevice->SetProperty(DIPROP_RANGE,&joy_axis_range.diph))){ + PrintDIError("SetProperty", res); + } + } + jint didft = (jint)lpddoi->dwType; + jstring name = env->NewStringUTF(lpddoi->tszName); + // Add the axis into our list + env->CallVoidMethod(obj, MID_AddAxis, list, identifier, didft, + name); + return DIENUM_CONTINUE; +} + +/* + * Class: org_java_games_input_DirectInputDevice + * Method: enumObjects + * Signature: (JLjava/util/ArrayList;)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputDevice_enumObjects + (JNIEnv* env, jobject obj, jlong lDevice, jobject list) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + ObjectParamData data(lpDevice, env, obj, list); + LPVOID pvRef = (LPVOID)&data; + DWORD dwFlags = DIDFT_ALL; + // Enum objects + HRESULT res = lpDevice->EnumObjects(EnumObjectsCallback, pvRef, dwFlags); + if (res != DI_OK) { + PrintDIError("EnumObjects", res); + return JNI_FALSE; + } + return JNI_TRUE; +} + +/* + ****************************************************************************** + * DirectInputKeyboard + ****************************************************************************** + */ + +/* + * Class: org_java_games_input_DirectInputKeyboard + * Method: pollNative + * Signature: (J[B)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputKeyboard_pollNative + (JNIEnv* env, jobject obj, jlong lDevice, jbyteArray baData) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + // Reacquire the device + HRESULT res = lpDevice->Acquire(); + if (res != DI_OK && res != S_FALSE) { + PrintDIError("Acquire", res); + return JNI_FALSE; + } + // Get the device state (data) + char data[256]; + res = lpDevice->GetDeviceState(sizeof(data), data); + if (res != DI_OK) { + PrintDIError("GetDeviceState", res); + return JNI_FALSE; + } + env->SetByteArrayRegion(baData, 0, (jsize)sizeof(data), (jbyte*)&data); + return JNI_TRUE; +} + +/* + * Enumeration callback to rename keyboard keys + * + * returns DIENUM_CONTINUE or DIENUM_STOP + */ +BOOL CALLBACK RenameKeysCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, + LPVOID pvRef) +{ + ObjectParamData* pData = (ObjectParamData*)pvRef; + //LPDIRECTINPUTDEVICE8 lpDevice = pData->lpDevice; + JNIEnv* env = pData->env; + jobject obj = pData->obj; + jint index = (jint)lpddoi->dwOfs; + jstring name = env->NewStringUTF(lpddoi->tszName); + env->CallVoidMethod(obj, MID_RenameKey, index, name); + return DIENUM_CONTINUE; +} + +/* + * Class: org_java_games_input_DirectInputKeyboard + * Method: renameKeys + * Signature: (J)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputKeyboard_renameKeys + (JNIEnv* env, jobject obj, jlong lDevice) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + ObjectParamData data(lpDevice, env, obj, NULL); + LPVOID pvRef = (LPVOID)&data; + DWORD dwFlags = DIDFT_ALL; + // Enum objects + HRESULT res = lpDevice->EnumObjects(RenameKeysCallback, pvRef, dwFlags); + if (res != DI_OK) { + PrintDIError("EnumObjects", res); + return JNI_FALSE; + } + return JNI_TRUE; +} + +/* + ****************************************************************************** + * DirectInputMouse + ****************************************************************************** + */ + +/* + * Class: org_java_games_input_DirectInputMouse + * Method: pollNative + * Signature: (J[B)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputMouse_pollNative + (JNIEnv* env, jobject obj, jlong lDevice, jbyteArray baData) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + // Reacquire the device + HRESULT res = lpDevice->Acquire(); + if (res != DI_OK && res != S_FALSE) { + PrintDIError("Acquire", res); + return JNI_FALSE; + } + // Get the data + DIMOUSESTATE data; + res = lpDevice->GetDeviceState(sizeof(data), &data); + if (res != DI_OK) { + PrintDIError("GetDeviceState", res); + return JNI_FALSE; + } + // Set the data in our array + env->SetByteArrayRegion(baData, 0, (jsize)sizeof(data), (jbyte*)&data); + return JNI_TRUE; +} + +/* + * Enumeration callback to rename mouse axes + * + * returns DIENUM_CONTINUE or DIENUM_STOP + */ +BOOL CALLBACK RenameAxesCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, + LPVOID pvRef) +{ + ObjectParamData* pData = (ObjectParamData*)pvRef; + //LPDIRECTINPUTDEVICE8 lpDevice = pData->lpDevice; + JNIEnv* env = pData->env; + jobject obj = pData->obj; + jobject identifier; + switch (lpddoi->dwOfs) { + case DIMOFS_X: + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, + FID_X); + break; + case DIMOFS_Y: + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, + FID_Y); + break; + case DIMOFS_Z: + identifier = env->GetStaticObjectField(CLASS_AxisIdentifier, + FID_Slider); + break; + case DIMOFS_BUTTON0: + identifier = env->GetStaticObjectField(CLASS_ButtonIdentifier, + FID_Left); + break; + case DIMOFS_BUTTON1: + identifier = env->GetStaticObjectField(CLASS_ButtonIdentifier, + FID_Right); + break; + case DIMOFS_BUTTON2: + identifier = env->GetStaticObjectField(CLASS_ButtonIdentifier, + FID_Middle); + break; + case DIMOFS_BUTTON3: + default: + return DIENUM_CONTINUE; // Not an axis we know + } + jstring name = env->NewStringUTF(lpddoi->tszName); + env->CallVoidMethod(obj, MID_RenameAxis, identifier, name); + return DIENUM_CONTINUE; +} + +/* + * Class: org_java_games_input_DirectInputMouse + * Method: renameAxes + * Signature: (J)Z + */ +extern "C" JNIEXPORT jboolean JNICALL +Java_net_java_games_input_DirectInputMouse_renameAxes + (JNIEnv* env, jobject obj, jlong lDevice) +{ + LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(long)lDevice; + ObjectParamData data(lpDevice, env, obj, NULL); + LPVOID pvRef = (LPVOID)&data; + DWORD dwFlags = DIDFT_ALL; + // Enum objects + HRESULT res = lpDevice->EnumObjects(RenameAxesCallback, pvRef, dwFlags); + if (res != DI_OK) { + PrintDIError("EnumObjects", res); + return JNI_FALSE; + } + return JNI_TRUE; +} + + |