shadowfacts/lwjgl2-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/lwjgl2-arm64.git synced 2026-04-05 06:25:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Removed Controller

Browse source
This commit is contained in:
Elias Naur 2005-01-18 15:32:13 +00:00
parent 8220b2e04c
commit 250a87767f
9 changed files with 4 additions and 1758 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/java/org/lwjgl/examples/spaceinvaders/Game.java
View file

@ -35,7 +35,6 @@ import java.util.ArrayList;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
@ -554,20 +553,17 @@ public class Game {
case Keyboard.KEY_LEFT:
return
Keyboard.isKeyDown(Keyboard.KEY_LEFT) ||
mouseX < 0 ||
(Controller.isCreated() && Controller.getX() < 0);
mouseX < 0;
case Keyboard.KEY_RIGHT:
return
Keyboard.isKeyDown(Keyboard.KEY_RIGHT) ||
mouseX > 0 ||
(Controller.isCreated() && Controller.getX() > 0);
mouseX > 0;
case Keyboard.KEY_SPACE:
return
Keyboard.isKeyDown(Keyboard.KEY_SPACE) ||
Mouse.isButtonDown(0) ||
(Controller.isCreated() && Controller.isButtonDown(0));
Mouse.isButtonDown(0);
}
return false;
}
@ -603,4 +599,4 @@ public class Game {
public Sprite getSprite(String ref) {
return new Sprite(textureLoader, ref);
}
}
}

391
src/java/org/lwjgl/input/Controller.java
View file

@ -1,391 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.input;
import java.util.HashMap;
import java.util.Map;
import org.lwjgl.Sys;
import org.lwjgl.opengl.Display;
import org.lwjgl.LWJGLException;
/**
* $Id$
* <br>
* A raw Controller interface. This can be used to poll the current state of a
* controllers buttons, and axis positions. The axis positions
* are returned as ints in the range -1000 to 1000.
*
* No buffering is available.
*
* Currently n (native limits) buttons, the x, y, z axis (also rotational x,y ,
* z axis) is supported along with a POV (or HAT) and a slider
*
* The Controller implementation currently only supports the first attached device.
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class Controller {
/** Has the controller been created? */
private static boolean created;
/** The controller buttons status */
private static boolean[] buttons;
/** X position, range -1000 to 1000 */
private static int x = 0;
/** X rotational position, range -1000 to 1000 */
private static int rx = 0;
/** Y position, range -1000 to 1000 */
private static int y = 0;
/** Y rotational position, range -1000 to 1000 */
private static int ry = 0;
/** Z position, range -1000 to 1000 */
private static int z = 0;
/** Z rotational position, range -1000 to 1000 */
private static int rz = 0;
/** Position of Point of View from -1 to 27000 (360 degrees) */
private static int pov;
/** Slider position, range -1000 to 1000 */
private static int slider = 0;
/** Constant specifying centered POV */
public static final int POV_CENTER = -1;
/** Constant specifying nortward POV */
public static final int POV_NORTH = 0;
/** Constant specifying southward POV */
public static final int POV_SOUTH = 18000;
/** Constant specifying eastward POV */
public static final int POV_EAST = 27000;
/** Constant specifying westward POV */
public static final int POV_WEST = 9000;
/** Number of buttons on the controller */
private static int buttonCount = -1;
/** Does this controller support a x axis */
private static boolean hasXAxis = false;
/** Does this controller support a rotational x axis */
private static boolean hasRXAxis = false;
/** Does this controller support an y axis */
private static boolean hasYAxis = false;
/** Does this controller support a rotational y axis */
private static boolean hasRYAxis = false;
/** Does this controller support a z axis */
private static boolean hasZAxis = false;
/** Does this controller support a rotational z axis */
private static boolean hasRZAxis = false;
/** Does this controller support a Point-Of-View (hat) */
private static boolean hasPOV = false;
/** Does this controller support a slider */
private static boolean hasSlider = false;
/** Button names. These are set upon create(), to names like BUTTON0, BUTTON1, etc. */
private static String[] buttonName;
private static final Map buttonMap = new HashMap(8);
/** Lazy initialization */
private static boolean initialized;
/**
* Controller cannot be constructed.
*/
private Controller() {
}
/**
* Static initialization
*/
private static void initialize() {
if (initialized)
return;
Sys.initialize();
initIDs();
initialized = true;
}
/**
* "Create" the controller. The display must first have been created.
* @throws LWJGLException if the controller could not be created for any reason
*/
public static void create() throws LWJGLException {
if (!Display.isCreated())
throw new IllegalStateException("Display must be created before you can create Controller");
initialize();
if (created) {
return;
}
nCreate();
// Assign names to all the buttons
buttonName = new String[buttons.length];
for (int i = 0; i < buttons.length; i ++) {
buttonName[i] = "BUTTON" + i;
buttonMap.put(buttonName[i], new Integer(i));
}
created = true;
}
/**
* @return true if the controller has been created
*/
public static boolean isCreated() {
return created;
}
/**
* "Destroy" the controller
*/
public static void destroy() {
if (!created) {
return;
}
created = false;
nDestroy();
}
/**
* Polls the controller.
*/
public static void poll() {
if (!created)
throw new IllegalStateException("Controller must be created before you can poll the device");
nPoll();
}
/**
* Tests if a particular button is down.
*
* @param button The index of the button you wish to test (0..buttonCount-1)
* @return true if the specified button is down
* @see #getButtonCount()
*/
public static boolean isButtonDown(int button) {
if (!created)
throw new IllegalStateException("Controller must be created before you can query button state");
return buttons[button];
}
/**
* @return true if the controller is buffered
*/
public static boolean isBuffered() {
return false;
}
/**
* Gets a button's name
* @param button The button
* @return a String with the button's human readable name in it or null if the button is unnamed
*/
public static String getButtonName(int button) {
if (button < 0 || button >= buttonName.length)
return null;
else
return buttonName[button];
}
/**
* Get's a button's index. If the button is unrecognised then -1 is returned.
* @param buttonName The button name
*/
public static int getButtonIndex(String buttonName) {
Integer ret = (Integer) buttonMap.get(buttonName);
if (ret == null)
return -1;
else
return ret.intValue();
}
/**
* Native method to poll the controller
*/
private static native void nPoll();
/**
* Native method to create the controller
*/
private static native void nCreate() throws LWJGLException;
/**
* Native method the destroy the controller
*/
private static native void nDestroy();
/**
* Register fields with the native library
*/
private static native void initIDs();
/**
* @return Returns the buttonCount.
*/
public static int getButtonCount() {
return buttonCount;
}
/**
* @return Returns whether POV is supported
*/
public static boolean hasPOV() {
return hasPOV;
}
/**
* @return Returns whether a rotational x axis is supported
*/
public static boolean hasRXAxis() {
return hasRXAxis;
}
/**
* @return Returns whether a rotational y axis is supported
*/
public static boolean hasRYAxis() {
return hasRYAxis;
}
/**
* @return Returns whether a rotational z axis is supported
*/
public static boolean hasRZAxis() {
return hasRZAxis;
}
/**
* @return Returns whether a slider is supported
*/
public static boolean hasSlider() {
return hasSlider;
}
/**
* @return Returns whether a x axis is supported
*/
public static boolean hasXAxis() {
return hasXAxis;
}
/**
* @return Returns whether a y axis is supported
*/
public static boolean hasYAxis() {
return hasYAxis;
}
/**
* @return Returns whether a z axis is supported
*/
public static boolean hasZAxis() {
return hasZAxis;
}
/**
* @return Returns the POV value
*/
public static int getPov() {
return pov;
}
/**
* @return Returns the rotational value of the x axis
*/
public static int getRx() {
return rx;
}
/**
* @return Returns the rotational value of the y axis
*/
public static int getRy() {
return ry;
}
/**
* @return Returns the rotational value of the z axis
*/
public static int getRz() {
return rz;
}
/**
* @return Returns the slider value
*/
public static int getSlider() {
return slider;
}
/**
* @return Returns the x axis value
*/
public static int getX() {
return x;
}
/**
* @return Returns the y axis value
*/
public static int getY() {
return y;
}
/**
* @return Returns the z axis value
*/
public static int getZ() {
return z;
}
}

18
src/java/org/lwjgl/opengl/Display.java
View file

@ -50,7 +50,6 @@ import java.util.HashSet;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
@ -232,9 +231,6 @@ public final class Display {
if (Keyboard.isCreated()) {
Keyboard.destroy();
}
if (Controller.isCreated()) {
Controller.destroy();
}
display_impl.destroyWindow();
}
@ -483,9 +479,6 @@ public final class Display {
if (Keyboard.isCreated()) {
Keyboard.poll();
}
if (Controller.isCreated()) {
Controller.poll();
}
}
/**
@ -594,17 +587,6 @@ public final class Display {
}
}
}
if (System.getProperty("os.name").startsWith("Win") && !Controller.isCreated() && !Boolean.getBoolean("org.lwjgl.opengl.Display.nocontroller")) {
try {
Controller.create();
} catch (LWJGLException e) {
if (Sys.DEBUG) {
e.printStackTrace(System.err);
} else {
Sys.log("Failed to create Controller: "+e);
}
}
}
}
}

202
src/java/org/lwjgl/test/input/ControllerCreationTest.java
View file

@ -1,202 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.test.input;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector2f;
/**
* $Id$
* <br>
* Controller creation test
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class ControllerCreationTest {
/** position of quad to draw */
private Vector2f position = new Vector2f(320.0f, 240.0f);
/** Creates a new instance of MouseTest */
public ControllerCreationTest() {
}
private void initialize(boolean fullscreen) {
try {
setDisplayMode();
Display.setFullscreen(fullscreen);
Display.create();
if(!Controller.isCreated()) {
throw new Exception("Controller could not be created");
}
} catch (Exception e) {
e.printStackTrace();
System.exit(-1);
}
initializeOpenGL();
}
/**
* Sets the display mode for fullscreen mode
*/
protected boolean setDisplayMode() {
// get modes
DisplayMode[] dm = org.lwjgl.util.Display.getAvailableDisplayModes(640, 480, -1, -1, -1, -1, 60, 60);
try {
org.lwjgl.util.Display.setDisplayMode(dm, new String[] {
"width=" + 640,
"height=" + 480,
"freq=" + 60,
"bpp=" + org.lwjgl.opengl.Display.getDisplayMode().getBitsPerPixel()
});
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
private void initializeOpenGL() {
GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}
public void executeTest() {
initialize(false);
System.out.println("Test ready:\n");
// windowed mode
System.out.println("=========== WINDOWED MODE ==============");
for(int i=0; i<2; i++) {
System.out.println("Test " + (i+1) + ":");
wiggleController();
System.out.println("");
}
// recreate display in fullscreen mode
System.out.print("Destroying display...");
Display.destroy();
System.out.println("success");
System.out.print("Entering fullscreen mode...");
try {
Display.destroy();
initialize(true);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("success");
// fullscreen mode
System.out.println("=========== FULLSCREEN MODE ==============");
for(int i=0; i<2; i++) {
System.out.println("Test " + (i+3) + ":");
wiggleController();
System.out.println("");
}
System.out.println("Test completed successfully!");
System.out.print("Shutting down...");
Display.destroy();
System.out.println("shutdown complete");
}
private void wiggleController() {
System.out.print("Please move the controller around");
long statustime = Sys.getTime();
long endtime = Sys.getTime() + Sys.getTimerResolution() * 5;
while (Sys.getTime() < endtime) {
Display.update();
//controller is a bit fuzzy
if(Controller.getX() > 100) {
position.x += 1;
} else if (Controller.getX() < -100) {
position.x -= 1;
}
if(Controller.getY() > 100) {
position.y -= 1;
} else if (Controller.getY() < -100) {
position.y += 1;
}
render();
if (Sys.getTime() - statustime > Sys.getTimerResolution()) {
System.out.print(".");
statustime = Sys.getTime();
}
}
System.out.println("thank you");
}
private void render() {
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
GL11.glPushMatrix();
GL11.glBegin(GL11.GL_POLYGON);
{
GL11.glColor3f(0.0f, 1.0f, 1.0f);
GL11.glVertex2f(position.x + 0.0f, position.y + 0.0f);
GL11.glColor3f(1.0f, 0.0f, 1.0f);
GL11.glVertex2f(position.x + 0.0f, position.y + 30.0f);
GL11.glVertex2f(position.x + 40.0f, position.y + 30.0f);
GL11.glColor3f(1.0f, 1.0f, 0.0f);
GL11.glVertex2f(position.x + 60.0f, position.y + 15.f);
GL11.glVertex2f(position.x + 40.0f, position.y + 0.0f);
}
GL11.glEnd();
GL11.glPopMatrix();
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ControllerCreationTest cct = new ControllerCreationTest();
cct.executeTest();
}
}

194
src/java/org/lwjgl/test/input/ControllerFieldTest.java
View file

@ -1,194 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.test.input;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import org.lwjgl.LWJGLException;
import org.lwjgl.input.Controller;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
/**
* $Id$
* <br>
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class ControllerFieldTest {
private Panel panel;
private Frame frame;
private Label[] labels;
/**
*
*/
private void executeTest() {
initialize();
if(frame != null) {
run();
}
destroy();
}
/**
*
*/
private void destroy() {
Display.destroy();
}
/**
*
*/
private void run() {
frame.setVisible(true);
String buttons;
while(frame.isVisible()) {
buttons = "";
if(Display.isActive()) {
Display.update();
}
labels[0].setText("" + Controller.getX());
labels[1].setText("" + Controller.getRx());
labels[2].setText("" + Controller.getY());
labels[3].setText("" + Controller.getRy());
labels[4].setText("" + Controller.getZ());
labels[5].setText("" + Controller.getRz());
labels[6].setText("" + Controller.getPov());
labels[7].setText("" + Controller.getSlider());
for(int i=0; i<Controller.getButtonCount(); i++) {
buttons += (Controller.isButtonDown(i)) ? "" + i + ", ": "";
}
labels[17].setText(buttons);
}
}
/**
* Sets the display mode for fullscreen mode
*/
protected boolean setDisplayMode() {
// get modes
DisplayMode[] dm = org.lwjgl.util.Display.getAvailableDisplayModes(320, 240, -1, -1, -1, -1, 60, 60);
try {
org.lwjgl.util.Display.setDisplayMode(dm, new String[] {
"width=" + 320,
"height=" + 240,
"freq=" + 60,
"bpp=" + org.lwjgl.opengl.Display.getDisplayMode().getBitsPerPixel()
});
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
*
*/
private void initialize() {
try {
setDisplayMode();
Display.create();
} catch (LWJGLException lwjgle) {
lwjgle.printStackTrace();
return;
}
if(!Controller.isCreated()) {
System.out.println("Unable to aquire controller - exiting");
return;
}
// create our panel, with lots of field names | value
panel = new Panel();
panel.setLayout(new GridLayout(0,2));
String[] fields = new String[] {
"x", "rx", "y", "ry",
"z", "rz", "pov", "slider",
"buttonCount", "hasXAxis", "hasRXAxis",
"hasYAxis", "hasRYAxis", "hasZAxis",
"hasRZAxis", "hasPOV", "hasSlider", "buttons"
};
labels = new Label[fields.length];
for(int i=0 ;i<fields.length; i++) {
panel.add(new Label(fields[i]));
panel.add(new Label(""));
labels[i] = (Label) panel.getComponent((i*2)+1);
}
frame = new Frame("ControllerFieldTest");
frame.setBounds(400, 400, 640, 480);
frame.add(panel);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
frame.dispose();
}
});
frame.pack();
// set initial fields
labels[8].setText("" + Controller.getButtonCount());
labels[9].setText("" + Controller.hasXAxis());
labels[10].setText("" + Controller.hasRXAxis());
labels[11].setText("" + Controller.hasYAxis());
labels[12].setText("" + Controller.hasRYAxis());
labels[13].setText("" + Controller.hasZAxis());
labels[14].setText("" + Controller.hasRZAxis());
labels[15].setText("" + Controller.hasPOV());
labels[16].setText("" + Controller.hasSlider());
}
public static void main(String[] args) {
ControllerFieldTest test = new ControllerFieldTest();
test.executeTest();
}
}

403
src/java/org/lwjgl/test/input/ControllerTest.java
View file

@ -1,403 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.test.input;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector2f;
import org.lwjgl.util.vector.Vector3f;
/**
* $Id$
* <br>
* Controller test
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class ControllerTest {
/** Controller fuzz */
public static final int FUZZ = 200;
/** Direction controller has moved */
private int direction;
/** Last button pressed */
private int lastButton = 0;
/** Last direction we scrolled in */
private int lastScrollDirection = -1;
/** Width of window */
private static int WINDOW_WIDTH = 640;
/** Height of window */
private static int WINDOW_HEIGHT = 640;
/** Triangle size (in ½) */
private Vector2f triangleSize = new Vector2f(120, 100);
/** Triangle color */
private Vector3f triangleColor[] = new Vector3f[] {
new Vector3f(1,1,1),
new Vector3f(1,0,0),
new Vector3f(0,1,0),
new Vector3f(0,0,1)
};
private Vector3f quadColor[] = new Vector3f[] {
new Vector3f(1,1,1),
new Vector3f(1,0,0),
new Vector3f(0,1,0),
new Vector3f(0,0,1)
};
/** Triangles to paint */
private Vector2f[] triangles = {
new Vector2f(WINDOW_WIDTH/2, WINDOW_HEIGHT - triangleSize.y),
new Vector2f(triangleSize.y, WINDOW_HEIGHT/2),
new Vector2f(WINDOW_WIDTH/2, triangleSize.y),
new Vector2f(WINDOW_WIDTH-triangleSize.y, WINDOW_HEIGHT/2)
};
/** Whether the test is closing */
private boolean closing = false;
/** Fullscreen or not */
public static final boolean FULLSCREEN = false;
/** Creates a new instance of ControllerTest */
public ControllerTest() {
}
private void initialize() {
// create display and opengl
setupDisplay();
}
/**
* Setup display
*/
private void setupDisplay() {
try {
setDisplayMode();
Display.setFullscreen(FULLSCREEN);
Display.setVSyncEnabled(true);
Display.create();
} catch (Exception e) {
e.printStackTrace();
System.exit(-1);
}
initializeOpenGL();
}
/**
* Sets the display mode for fullscreen mode
*/
protected boolean setDisplayMode() {
// get modes
DisplayMode[] dm = org.lwjgl.util.Display.getAvailableDisplayModes(WINDOW_WIDTH, WINDOW_HEIGHT, -1, -1, -1, -1, 60, 60);
try {
org.lwjgl.util.Display.setDisplayMode(dm, new String[] {
"width=" + WINDOW_WIDTH,
"height=" + WINDOW_HEIGHT,
"freq=" + 60,
"bpp=" + org.lwjgl.opengl.Display.getDisplayMode().getBitsPerPixel()
});
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* Initializes OpenGL
*
*/
private void initializeOpenGL() {
GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}
/**
* Executes the actual test
*/
public void executeTest() {
initialize();
runTest();
Display.destroy();
}
/**
* Runs the test
*/
private void runTest() {
// while not exiting
while (!closing) {
handleWindow();
// secondary check
if(!closing) {
// poll and check keyboard and mouse
handleKeyboard();
handleController();
// pause and continue if minimized
if(!Display.isVisible()) {
pause(100);
render();
continue;
}
// render and flip
logic();
render();
}
Thread.yield();
}
}
/**
* Pauses the current thread for a specified time
*
* @param time milliseconds to pause
*/
private void pause(long time) {
try {
Thread.sleep(time);
} catch (InterruptedException inte) {
inte.printStackTrace();
}
}
/**
* Handles the window
*/
private void handleWindow() {
Display.update();
closing = Display.isCloseRequested();
}
/**
* handles the controller
*/
private void handleController() {
readController();
}
/**
* Reads the controller
*/
private void readController() {
// get last button down
for(int i=0;i<Controller.getButtonCount(); i++) {
if(Controller.isButtonDown(i)) {
lastButton = i;
}
}
updateState();
}
/**
* Updates our "model"
*/
private void updateState() {
direction = -1;
// get out if no movement
if (Controller.getX() == Controller.getY() && Controller.getX() == 0) {
if(!Controller.hasPOV()) {
return;
}
}
// determine direction moved
// ============================
if(Controller.getX() > FUZZ) {
direction = 3;
}
if(Controller.getX() < -FUZZ) {
direction = 1;
}
if(Controller.getY() > FUZZ) {
direction = 2;
}
if(Controller.getY() < -FUZZ) {
direction = 0;
}
// ----------------------------
if(direction > -1) {
// based on which button was last pushed, update model
switch(lastButton) {
case -1:
break;
case 1:
triangleColor[direction].y = 1;
break;
case 2:
triangleColor[direction].z = 1;
break;
case 3:
triangleColor[direction].x = 1;
triangleColor[direction].y = 1;
triangleColor[direction].z = 1;
break;
case 0: // fall through
default:
triangleColor[direction].x = 1;
break;
}
}
if(Controller.hasPOV()) {
// get direction to update in
switch(Controller.getPov()) {
case Controller.POV_CENTER:
return;
case Controller.POV_SOUTH:
case Controller.POV_EAST:
lastScrollDirection++;
break;
case Controller.POV_NORTH:
case Controller.POV_WEST:
lastScrollDirection--;
break;
}
// over/underflow
if(lastScrollDirection < 0) {
lastScrollDirection = 3;
}
if(lastScrollDirection > 3) {
lastScrollDirection = 0;
}
// update colors
quadColor[lastScrollDirection].x = (float) Math.random();
quadColor[lastScrollDirection].y = (float) Math.random();
quadColor[lastScrollDirection].z = (float) Math.random();
}
}
/**
* Handles the keyboard
*/
private void handleKeyboard() {
// closing on ESCAPE
if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
closing = true;
}
}
/**
* Does the "model logic"
*/
private void logic() {
// "we fade to black"
// ===========================================
for(int i=0; i<triangleColor.length; i++) {
triangleColor[i].x -= 0.01;
triangleColor[i].y -= 0.01;
triangleColor[i].z -= 0.01;
}
for(int i=0; i<quadColor.length; i++) {
quadColor[i].x -= 0.01;
quadColor[i].y -= 0.01;
quadColor[i].z -= 0.01;
}
// -------------------------------------------
}
/**
* Render our triangles
*/
private void render() {
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
// for each triangle, render it at position, rotating degrees for each
for(int i=0; i<triangles.length; i++) {
GL11.glPushMatrix(); {
GL11.glTranslatef(triangles[i].x, triangles[i].y, 0);
GL11.glRotatef(i*90, 0, 0, 1);
GL11.glColor3f(triangleColor[i].x, triangleColor[i].y, triangleColor[i].z);
GL11.glBegin(GL11.GL_TRIANGLES); {
GL11.glVertex2f(0, triangleSize.y);
GL11.glVertex2f(-triangleSize.x, -triangleSize.y);
GL11.glVertex2f(+triangleSize.x, -triangleSize.y);
}
GL11.glEnd();
}
GL11.glPopMatrix();
}
// paint quad in the middle (yes, wasting cpu cycles by not precalculating)
GL11.glBegin(GL11.GL_QUADS); {
GL11.glColor3f(quadColor[0].x, quadColor[0].y, quadColor[0].z);
GL11.glVertex2f(WINDOW_WIDTH/2-triangleSize.x, WINDOW_HEIGHT/2-triangleSize.x);
GL11.glColor3f(quadColor[1].x, quadColor[1].y, quadColor[1].z);
GL11.glVertex2f(WINDOW_WIDTH/2+triangleSize.x, WINDOW_HEIGHT/2-triangleSize.x);
GL11.glColor3f(quadColor[2].x, quadColor[2].y, quadColor[2].z);
GL11.glVertex2f(WINDOW_WIDTH/2+triangleSize.x, WINDOW_HEIGHT/2+triangleSize.x);
GL11.glColor3f(quadColor[3].x, quadColor[3].y, quadColor[3].z);
GL11.glVertex2f(WINDOW_WIDTH/2-triangleSize.x, WINDOW_HEIGHT/2+triangleSize.x);
}
GL11.glEnd();
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ControllerTest ct = new ControllerTest();
ct.executeTest();
}
}