From e03af51904e412c56382cdf3557f8adbef1877d0 Mon Sep 17 00:00:00 2001 From: Markil3 <> Date: Sun, 13 Dec 2020 15:45:31 -0700 Subject: [PATCH] Adds an application state that displays connected controllers. It still relies pretty heavily on Lemur. I'm going to have to fix that. --- build.gradle | 40 +- .../controller/JoystickPreviewScreen.java | 743 ++++++++++++++++++ src/main/java/markil3/controller/Main.java | 65 ++ 3 files changed, 847 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index d55c7d3..40f1d13 100644 --- a/build.gradle +++ b/build.gradle @@ -27,7 +27,7 @@ plugins { // Apply the java plugin to add support for Java id "application" id "distribution" -// id "com.github.johnrengelman.shadow" version "5.0.0" + id "com.github.johnrengelman.shadow" version "5.0.0" id "edu.sc.seis.launch4j" version "2.4.5" id "edu.sc.seis.macAppBundle" version "2.3.0" } @@ -37,6 +37,9 @@ repositories { jcenter() mavenCentral() maven { url 'https://jitpack.io' } + maven { + url "https://dl.bintray.com/jmonkeyengine/org.jmonkeyengine" + } } sourceCompatibility = "1.8" @@ -55,6 +58,7 @@ dependencies { implementation "${jme3.g}:jme3-core:${jme3.version}" implementation "${jme3.g}:jme3-desktop:${jme3.version}" + implementation 'org.jmonkeyengine:jme3-testdata:3.3.2-stable' implementation "${jme3.g}:jme3-lwjgl3:${jme3.version}" @@ -85,3 +89,37 @@ jar { } } +shadowJar { + baseName = rootProject.name + classifier = "universal" + version = rootProject.version + mainClassName = project.mainClassName +} + +launch4j { + mainClassName = project.mainClassName + outfile = rootProject.name + "-" + project.version + "-windows.exe" + copyConfigurable = shadowJar.outputs.files + jar = "lib/${shadowJar.archiveName}" + bundledJrePath = "jre" + //icon = new File(sourceSets.main.resources.srcDirs[0], "icon256.ico") +} + +createExe.doLast({ + println project.tasks.installDist.outputs.files.getClass() + for (file in new File(installDist.outputs.files[0], "lib").listFiles()) { + println file + } +}) + +macAppBundle { + mainClassName = project.mainClassName + icon = "myIcon.icns" + if (Os.isFamily(Os.FAMILY_MAC) && (appStyle == 'Oracle' || appStyle == 'universalJavaApplicationStub')) { + bundleJRE = true + } + javaProperties.put("apple.laf.useScreenMenuBar", "true") + backgroundImage = "doc/macbackground.png" + jarTask = "shadowJar" +} + diff --git a/src/main/java/markil3/controller/JoystickPreviewScreen.java b/src/main/java/markil3/controller/JoystickPreviewScreen.java index 9792e7e..7748eda 100644 --- a/src/main/java/markil3/controller/JoystickPreviewScreen.java +++ b/src/main/java/markil3/controller/JoystickPreviewScreen.java @@ -11,7 +11,12 @@ package markil3.controller; import com.jme3.app.Application; +import com.jme3.app.SimpleApplication; import com.jme3.app.state.BaseAppState; +import com.jme3.asset.AssetManager; +import com.jme3.input.Joystick; +import com.jme3.input.JoystickAxis; +import com.jme3.input.JoystickButton; import com.jme3.input.RawInputListener; import com.jme3.input.event.JoyAxisEvent; import com.jme3.input.event.JoyButtonEvent; @@ -19,6 +24,49 @@ import com.jme3.input.event.KeyInputEvent; import com.jme3.input.event.MouseButtonEvent; import com.jme3.input.event.MouseMotionEvent; import com.jme3.input.event.TouchEvent; +import com.jme3.material.Material; +import com.jme3.material.RenderState.BlendMode; +import com.jme3.math.ColorRGBA; +import com.jme3.math.FastMath; +import com.jme3.math.Vector2f; +import com.jme3.math.Vector3f; +import com.jme3.scene.Geometry; +import com.jme3.scene.Node; +import com.jme3.scene.Spatial; +import com.jme3.scene.shape.Quad; +import com.simsilica.lemur.Axis; +import com.simsilica.lemur.Button; +import com.simsilica.lemur.Command; +import com.simsilica.lemur.Container; +import com.simsilica.lemur.FillMode; +import com.simsilica.lemur.Label; +import com.simsilica.lemur.TabbedPanel; +import com.simsilica.lemur.component.BoxLayout; +import com.simsilica.lemur.event.MouseEventControl; +import com.simsilica.lemur.event.MouseListener; +import com.simsilica.lemur.style.ElementId; + +import org.slf4j.LoggerFactory; + +import java.util.HashMap; +import java.util.Map; + +import static markil3.controller.Main.ACTION_BOTTOM; +import static markil3.controller.Main.ACTION_LEFT; +import static markil3.controller.Main.ACTION_RIGHT; +import static markil3.controller.Main.ACTION_TOP; +import static markil3.controller.Main.DPAD_DOWN; +import static markil3.controller.Main.DPAD_LEFT; +import static markil3.controller.Main.DPAD_RIGHT; +import static markil3.controller.Main.DPAD_UP; +import static markil3.controller.Main.L1; +import static markil3.controller.Main.L2; +import static markil3.controller.Main.L3; +import static markil3.controller.Main.R1; +import static markil3.controller.Main.R2; +import static markil3.controller.Main.R3; +import static markil3.controller.Main.SELECT; +import static markil3.controller.Main.START; /** * @author Markil 3 @@ -31,35 +79,730 @@ import com.jme3.input.event.TouchEvent; public class JoystickPreviewScreen extends BaseAppState implements RawInputListener { + @SuppressWarnings("unused") + private static final org.slf4j.Logger logger = + org.slf4j.LoggerFactory.getLogger(JoystickPreviewScreen.class); + + static class GamepadView extends Node + { + + AssetManager assetManager; + JoystickPreviewScreen prevScreen; + + float xAxis = 0; + float yAxis = 0; + float zAxis = 0; + float zRotation = 0; + + float lastPovX = 0; + float lastPovY = 0; + + float leftTrig = -1F; + float rightTrig = -1F; + + Geometry leftStick; + Geometry rightStick; + + Map buttons = new HashMap<>(); + + private boolean l2; + + private boolean r2; + + GamepadView(JoystickPreviewScreen prevScreen, AssetManager assetManager) + { + super("gamepad"); + + this.prevScreen = prevScreen; + this.assetManager = assetManager; + + // Sizes naturally for the texture size. All positions will + // be in that space because it's easier. + int size = 512; + + Material m = new Material(assetManager, + "Common/MatDefs/Misc/Unshaded.j3md"); + m.setTexture("ColorMap", assetManager + .loadTexture("Interface/Joystick/gamepad-buttons.png")); + m.getAdditionalRenderState().setBlendMode(BlendMode.Alpha); + Geometry buttonPanel = + new Geometry("buttons", new Quad(size, size)); + buttonPanel.setLocalTranslation(0, 0, -1); + buttonPanel.setMaterial(m); + attachChild(buttonPanel); + + m = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); + m.setTexture("ColorMap", assetManager + .loadTexture("Interface/Joystick/gamepad-frame.png")); + m.getAdditionalRenderState().setBlendMode(BlendMode.Alpha); + Geometry frame = new Geometry("frame", new Quad(size, size)); + frame.setMaterial(m); + attachChild(frame); + + m = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md"); + m.setTexture("ColorMap", assetManager + .loadTexture("Interface/Joystick/gamepad-stick.png")); + m.getAdditionalRenderState().setBlendMode(BlendMode.Alpha); + leftStick = new Geometry("leftStick", new Quad(64, 64)); + leftStick.setMaterial(m); + attachChild(leftStick); + rightStick = new Geometry("rightStick", new Quad(64, 64)); + rightStick.setMaterial(m); + attachChild(rightStick); + + // A "standard" mapping... fits a majority of my game pads + addButton(ACTION_TOP, 371, 512 - 176, 42, 42); + addButton(ACTION_RIGHT, 407, 512 - 212, 42, 42); + addButton(ACTION_BOTTOM, 371, 512 - 248, 42, 42); + addButton(ACTION_LEFT, 334, 512 - 212, 42, 42); + + // Front buttons Some of these have the top ones and the bottoms + // ones flipped. + addButton(L1, 67, 512 - 111, 95, 21); + addButton(R1, 348, 512 - 111, 95, 21); + addButton(L2, 67, 512 - 89, 95, 21); + addButton(R2, 348, 512 - 89, 95, 21); + + // Select and start buttons + addButton(SELECT, 206, 512 - 198, 48, 30); + addButton(START, 262, 512 - 198, 48, 30); + + // Joystick push buttons + addButton(L3, 147, 512 - 300, 75, 70); + addButton(R3, 285, 512 - 300, 75, 70); + + // +Y + // -X +X + // -Y + // + addButton(DPAD_UP, 96, 512 - 174, 40, 38); + addButton(DPAD_RIGHT, 128, 512 - 208, 40, 38); + addButton(DPAD_DOWN, 96, 512 - 239, 40, 38); + addButton(DPAD_LEFT, 65, 512 - 208, 40, 38); + + resetPositions(); + } + + private void addButton(String name, float x, float y, float width, + float height) + { + ButtonView b = + new ButtonView(this.prevScreen, this.assetManager, name, x, + y, width, height); + attachChild(b); + buttons.put(name, b); + } + + void setAxisValue(JoystickAxis axis, float value) + { + LoggerFactory.getLogger(axis.getJoystick().getName()) + .info(axis.getJoystick().getName() + "\n\tAxis:" + + axis.getName() + " (" + axis.getAxisId() + ")=" + + value); + if (this.prevScreen != null) + { + if (this.prevScreen.labels == null || + this.prevScreen.labels[axis.getJoystick() + .getJoyId()][0] == null || + !this.prevScreen.labels[axis.getJoystick() + .getJoyId()][0].getText() + .equals(axis.getJoystick().getName())) + { + this.prevScreen.setLabels(axis.getJoystick()); + } + } + if (axis == axis.getJoystick().getXAxis()) + { + setXAxis(value); + } + else if (axis == axis.getJoystick().getYAxis()) + { + setYAxis(-value); + } + else if (axis == axis.getJoystick().getAxis(JoystickAxis.Z_AXIS)) + { + // Note: in the above condition, we could check the axis name + // but + // I have at least one joystick that reports 2 "Z Axis" + // axes. + // In this particular case, the first one is the right + // one so + // a name based lookup will find the proper one. It's + // a problem + // because the erroneous axis sends a constant stream + // of values. + setZAxis(value); + } + else if (axis == + axis.getJoystick().getAxis(JoystickAxis.Z_ROTATION)) + { + setZRotation(-value); + } + else if (axis == + axis.getJoystick().getAxis(JoystickAxis.LEFT_TRIGGER)) + { + if (axis.getJoystick().getButton(L2) == null) + { + // left/right triggers sometimes only show up as axes + boolean pressed = value > 0; + if (pressed != this.buttons.get(L2). + isDown()) + { + setButtonValue(L2, pressed); + } + } + } + else if (axis == + axis.getJoystick().getAxis(JoystickAxis.RIGHT_TRIGGER)) + { + if (axis.getJoystick().getButton(R2) == null) + { + // left/right triggers sometimes only show up as axes + boolean pressed = value > 0; + if (pressed != this.buttons.get(R2). + isDown()) + { + setButtonValue(R2, pressed); + } + } + } + else if (axis == axis.getJoystick().getPovXAxis()) + { + if (lastPovX < 0) + { + setButtonValue(DPAD_LEFT, false); + } + else if (lastPovX > 0) + { + setButtonValue(DPAD_RIGHT, false); + } + if (value < 0) + { + setButtonValue(DPAD_LEFT, true); + } + else if (value > 0) + { + setButtonValue(DPAD_RIGHT, true); + } + lastPovX = value; + } + else if (axis == axis.getJoystick().getPovYAxis()) + { + if (lastPovY < 0) + { + setButtonValue(DPAD_DOWN, false); + } + else if (lastPovY > 0) + { + setButtonValue(DPAD_UP, false); + } + if (value < 0) + { + setButtonValue(DPAD_DOWN, true); + } + else if (value > 0) + { + setButtonValue(DPAD_UP, true); + } + lastPovY = value; + } + if (this.prevScreen != null) + { + this.prevScreen.labels[axis.getJoystick().getJoyId()][axis. + getAxisId() * 2 + 2].setText(Float.toString(value)); + } + } + + void setButtonValue(JoystickButton button, boolean isPressed) + { + LoggerFactory.getLogger(button.getJoystick().getName()) + .info(button.getJoystick().getName() + "\n\tButton:" + + button.getName() + " (" + button.getButtonId() + + ")=" + (isPressed ? "Down" : "Up")); + if (this.prevScreen != null) + { + if (this.prevScreen.labels == null || + this.prevScreen.labels[button.getJoystick() + .getJoyId()][0] == null || + !this.prevScreen.labels[button.getJoystick() + .getJoyId()][0].getText() + .equals(button.getJoystick().getName())) + { + this.prevScreen.setLabels(button.getJoystick()); + } + } + if (button.getLogicalId().equals(L2)) + { + l2 = isPressed; + setButtonValue(button.getLogicalId(), + isPressed || this.leftTrig >= 0F); + } + else if (button.getLogicalId().equals(R2)) + { + r2 = isPressed; + setButtonValue(button.getLogicalId(), + isPressed || this.rightTrig >= 0F); + } + else + { + setButtonValue(button.getLogicalId(), isPressed); + } + if (this.prevScreen != null) + { + try + { + this.prevScreen.labels[button.getJoystick().getJoyId()][2 * + (button.getButtonId() + + button.getJoystick().getAxisCount()) + 3] + .setText(Boolean.toString(isPressed)); + } + catch (ArrayIndexOutOfBoundsException aie) + { + logger.error("Couldn't find index for button (" + + button.getName() + ", " + button.getLogicalId() + + ", " + button.getButtonId() + ")", aie); +// throw new RuntimeException( +// "Couldn't find index for button (" + +// button.getName() + ", " + +// button.getLogicalId() + ", " + +// button.getButtonId() + ")", aie); + } + } + // lastButton = button; + } + + void setButtonValue(String name, boolean isPressed) + { + ButtonView view = buttons.get(name); + if (view != null) + { + if (isPressed) + { + view.down(); + } + else + { + view.up(); + } + } + } + + void setXAxis(float f) + { + xAxis = f; + resetPositions(); + } + + void setYAxis(float f) + { + yAxis = f; + resetPositions(); + } + + void setZAxis(float f) + { + zAxis = f; + resetPositions(); + } + + void setZRotation(float f) + { + zRotation = f; + resetPositions(); + } + + private void resetPositions() + { + + float xBase = 155; + float yBase = 212; + + Vector2f dir = new Vector2f(xAxis, yAxis); + float length = Math.min(1, dir.length()); + dir.normalizeLocal(); + + float angle = dir.getAngle(); + float x = FastMath.cos(angle) * length * 10; + float y = FastMath.sin(angle) * length * 10; + leftStick.setLocalTranslation(xBase + x, yBase + y, 0); + + xBase = 291; + dir = new Vector2f(zAxis, zRotation); + length = Math.min(1, dir.length()); + dir.normalizeLocal(); + + angle = dir.getAngle(); + x = FastMath.cos(angle) * length * 10; + y = FastMath.sin(angle) * length * 10; + rightStick.setLocalTranslation(xBase + x, yBase + y, 0); + } + } + + static class ButtonView extends Node + { + + private final JoystickPreviewScreen prevScreen; + private int state = 0; + private Material material; + private ColorRGBA hilite = new ColorRGBA(0.0f, 0.75f, 0.75f, 0.5f); + + ButtonView(AssetManager assetManager, String name, float x, float y, + float width, float height) + { + this(null, assetManager, name, x, y, width, height); + } + + ButtonView(JoystickPreviewScreen prevScreen, AssetManager assetManager, + String name, float x, float y, float width, float height) + { + super("Button:" + name); + setLocalTranslation(x, y, -0.5f); + + this.prevScreen = prevScreen; + + material = new Material(assetManager, + "Common/MatDefs/Misc/Unshaded.j3md"); + material.setColor("Color", hilite); + material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha); + + Geometry g = new Geometry("highlight", new Quad(width, height)); + g.setMaterial(material); + attachChild(g); + + resetState(); + addControl(new MouseEventControl(new MouseListener() + { + @Override + public void mouseMoved(MouseMotionEvent event, Spatial target, + Spatial capture) + { + } + + @Override + public void mouseExited(MouseMotionEvent event, Spatial target, + Spatial capture) + { + if (prevScreen != null) + { + if (prevScreen.refLabel.getText().equals(name)) + { + prevScreen.refLabel.setText(""); + } + } + } + + @Override + public void mouseEntered(MouseMotionEvent event, Spatial target, + Spatial capture) + { + if (prevScreen != null) + { + prevScreen.refLabel.setText(name); + prevScreen.resize(prevScreen.getApplication() + .getViewPort().getCamera().getWidth(), + prevScreen.getApplication().getViewPort() + .getCamera().getHeight()); + } + } + + @Override + public void mouseButtonEvent(MouseButtonEvent event, + Spatial target, Spatial capture) + { + } + })); + } + + private void resetState() + { + if (state <= 0) + { + setCullHint(CullHint.Always); + } + else + { + setCullHint(CullHint.Dynamic); + } + + // System.out.println(getName() + " state:" + state); + } + + public boolean isDown() + { + return this.state > 0; + } + + public void down() + { + this.state++; + this.resetState(); + } + + public void up() + { + this.state--; + this.resetState(); + } + } + + protected Container gui; + + private TabbedPanel choicesCont; + + private Container[] gamepadCont; + + private GamepadView[] gamepadView; + + private Label[][] labels; + + private Label refLabel = + new Label("Axis X/Axis Y", new ElementId("joystick.label")); + + private Map lastValues = new HashMap<>(); + + /** + * + */ + public JoystickPreviewScreen() + { + this.gui = new Container(); +// this.gui.setLayout( +// new CenterAlignLayout(HAlignment.Center, VAlignment.Center, +// FillMode.None, FillMode.None)); + + this.choicesCont = new TabbedPanel(); + this.gui.addChild(choicesCont); + + this.gui.attachChild(this.refLabel); + } @Override public void initialize(Application app) { + int mostButtons = 0; + Joystick joy; + int l = this.getApplication().getInputManager().getJoysticks().length; + + if (this.gamepadCont != null) + { + for (Container cont : this.gamepadCont) + { + if (cont != null) + { + cont.removeFromParent(); + } + } + } + for (int i = 0; i < l; i++) + { + joy = app.getInputManager().getJoysticks()[i]; + mostButtons = Math.max(joy.getAxisCount() + joy.getButtonCount(), + mostButtons); + } + this.labels = new Label[l][mostButtons * 2 + 3]; + this.gamepadCont = new Container[this.getApplication().getInputManager() + .getJoysticks().length]; + this.gamepadView = + new GamepadView[this.getApplication().getInputManager() + .getJoysticks().length]; + for (int i = 0; i < l; i++) + { + joy = this.getApplication().getInputManager().getJoysticks()[i]; + this.gamepadCont[i] = new Container(); + this.gamepadCont[i].setLayout(new BoxLayout(Axis.Y, FillMode.None)); + choicesCont + .addTab("Gamepad " + joy.getJoyId(), this.gamepadCont[i]); + // this.gamepadCont[i].addChild(new Label(joy.getName())); + this.gamepadView[i] = new GamepadView(this, this.getApplication().getAssetManager()); + this.gamepadView[i].setLocalTranslation(-128, -384, 0); + this.gamepadCont[i].attachChild(this.gamepadView[i]); + } + choicesCont.addTab("Back", null); + + // this.initNavState(); + // this.setFocus(this.playButton); + this.setEnabled(true); + + ((SimpleApplication) this.getApplication()).getGuiNode().attachChild(this.gui); + this.resize(((SimpleApplication) this.getApplication()).getCamera().getWidth(), ((SimpleApplication) this.getApplication()).getCamera().getHeight()); + this.setEnabled(true); } @Override protected void cleanup(Application app) { + } @Override protected void onEnable() { + this.getApplication().getInputManager().addRawInputListener(this); } @Override protected void onDisable() { + this.getApplication().getInputManager().removeRawInputListener(this); + } + + private void setLabels(Joystick joy) + { + ElementId elId = new ElementId("joystick.label"); + if (labels != null) + { + for (Label label : this.labels[joy.getJoyId()]) + { + if (label != null) + { + label.removeFromParent(); + } + } + } + // this.labels = new Label[joy.getJoyId()][(joy.getAxisCount() + + // joy.getButtonCount()) * 2 + 1]; + if (this.labels != null) + { + this.labels[joy.getJoyId()][0] = new Label(joy.getName(), elId); + this.gamepadCont[joy.getJoyId()] + .attachChild(this.labels[joy.getJoyId()][0]); + this.labels[joy.getJoyId()][1] = + new Label("Axis Index: Axis Name (logical ID, axis ID)", + elId); + this.labels[joy.getJoyId()][1].setLocalTranslation(20, -25, 0); + this.gamepadCont[joy.getJoyId()] + .attachChild(this.labels[joy.getJoyId()][1]); + for (int i = 0; i < joy.getAxisCount(); i++) + { + JoystickAxis axis = joy.getAxes().get(i); + try + { + Label label = new Label((i) + ": " + axis.getName() + " (" + + axis.getLogicalId() + ", " + axis.getAxisId() + + "): ", elId); + label.setLocalTranslation(20, -25 * (i + 2), 0); + this.labels[joy.getJoyId()][i * 2 + 1] = label; + Label label2 = new Label("-1.0", elId); + label2.setLocalTranslation(label.getLocalTranslation() + .add(label.getPreferredSize().x, 0, 0)); + this.labels[joy.getJoyId()][i * 2 + 2] = label2; + this.gamepadCont[joy.getJoyId()].attachChild(label); + this.gamepadCont[joy.getJoyId()].attachChild(label2); + } + catch (ArrayIndexOutOfBoundsException aie) + { + logger.error( + "Couldn't find index for axis (" + axis.getName() + + ", " + axis.getLogicalId() + ", " + + axis.getAxisId() + ")", aie); +// throw new RuntimeException( +// "Couldn't find index for button " + i + " (" + +// axis.getName() + ", " + +// axis.getLogicalId() + ", " + +// axis.getAxisId() + ")", aie); + } + } + int firstButtonIndex = 2 * joy.getAxisCount() + 1; + this.labels[joy.getJoyId()][firstButtonIndex] = new Label( + "Button Index: Button Name (logical ID, button " + "ID)", + elId); + this.labels[joy.getJoyId()][firstButtonIndex].setLocalTranslation( + this.gui.getPreferredSize().x - + this.labels[joy.getJoyId()][firstButtonIndex] + .getPreferredSize().x, -25, 0); + this.gamepadCont[joy.getJoyId()] + .attachChild(this.labels[joy.getJoyId()][firstButtonIndex]); + for (int i = 0; i < joy.getButtonCount(); i++) + { + JoystickButton button = joy.getButtons().get(i); + try + { + Label label2 = new Label("false", elId); + label2.setLocalTranslation(this.gui.getPreferredSize().x - + label2.getPreferredSize().x, -25 * (i + 2), 0); + Label label = new Label( + (i + joy.getAxisCount()) + ": " + button.getName() + + " (" + button.getLogicalId() + ", " + + button.getButtonId() + "): ", elId); + label.setLocalTranslation(label2.getLocalTranslation() + .add(-label.getPreferredSize().x, 0, 0)); + this.labels[joy.getJoyId()][2 * (i + joy.getAxisCount()) + + 2] = label; + this.labels[joy.getJoyId()][2 * (i + joy.getAxisCount()) + + 3] = label2; + this.gamepadCont[joy.getJoyId()].attachChild(label); + this.gamepadCont[joy.getJoyId()].attachChild(label2); + } + catch (ArrayIndexOutOfBoundsException aie) + { + logger.error("Couldn't find index for button (" + + button.getName() + ", " + button.getLogicalId() + + ", " + button.getButtonId() + ")", aie); +// throw new RuntimeException( +// "Couldn't find index for button " + i + " (" + +// button.getName() + ", " + +// button.getLogicalId() + ", " + +// button.getButtonId() + ")", aie); + } + } + } + } + + public void resize(int width, int height) + { + this.gui.setPreferredSize(new Vector3f(width, height, 0)); + this.gui.setLocalTranslation(0, this.gui.getPreferredSize().y, 0); + this.choicesCont.setPreferredSize(new Vector3f(width, height, 0)); + this.choicesCont.setLocalTranslation(width / 2F, height / 2F, 0); + if (this.gamepadView != null) + { + for (GamepadView view : this.gamepadView) + { + view.setLocalTranslation(width / 2F - 256F, -512F, 0); + } + } + this.refLabel.setLocalTranslation( + (width - this.refLabel.getPreferredSize().x) / 2F, 0, 0); } @Override public void onJoyAxisEvent(JoyAxisEvent evt) { + // setViewedJoystick(evt.getAxis().getJoystick()); +// this.gamepadView[evt.getJoyIndex()] +// .setAxisValue(evt.getAxis(), evt.getValue()); + Float last = this.lastValues.remove(evt.getAxis()); + float value = evt.getValue(); + + // Check the axis dead zone. InputManager normally does this + // by default but not for raw events like we get here. + float effectiveDeadZone = Math.max(this.getApplication(). + getInputManager().getAxisDeadZone(), evt. + getAxis().getDeadZone()); + if (Math.abs(value) < effectiveDeadZone) + { + if (last == null) + { + // Just skip the event + return; + } + // Else set the value to 0 + lastValues.remove(evt.getAxis()); + value = 0; + } + this.gamepadView[evt.getJoyIndex()].setAxisValue(evt.getAxis(), value); + if (value != 0) + { + lastValues.put(evt.getAxis(), value); + } } @Override public void onJoyButtonEvent(JoyButtonEvent evt) { + // setViewedJoystick(evt.getButton().getJoystick()); + this.gamepadView[evt.getJoyIndex()] + .setButtonValue(evt.getButton(), evt.isPressed()); } @Override diff --git a/src/main/java/markil3/controller/Main.java b/src/main/java/markil3/controller/Main.java index 34242bb..be67546 100644 --- a/src/main/java/markil3/controller/Main.java +++ b/src/main/java/markil3/controller/Main.java @@ -9,10 +9,13 @@ */ package markil3.controller; +import com.jme3.app.DebugKeysAppState; import com.jme3.app.SimpleApplication; +import com.jme3.app.StatsAppState; import com.jme3.input.DefaultJoystickAxis; import com.jme3.input.Joystick; import com.jme3.input.JoystickAxis; +import com.jme3.input.JoystickButton; import com.jme3.input.JoystickCompatibilityMappings; import com.jme3.material.Material; import com.jme3.math.ColorRGBA; @@ -43,6 +46,61 @@ public class Main extends SimpleApplication public static File GAME_FOLDER; public static File CALIBRATION_FILE; + /** + * Triangle on Playstation, Y on Xbox, and X on Nintendo. + */ + public static final String ACTION_TOP = JoystickButton.BUTTON_0; + /** + * Circle on Playstation, B on Xbox, and A on Nintendo. + */ + public static final String ACTION_RIGHT = JoystickButton.BUTTON_1; + /** + * X on Playstation, A on Xbox, and B on Nintendo. + */ + public static final String ACTION_BOTTOM = JoystickButton.BUTTON_2; + /** + * Square on Playstation, X on Xbox, and Y on Nintendo. + */ + public static final String ACTION_LEFT = JoystickButton.BUTTON_3; + public static final String L1 = JoystickButton.BUTTON_4; + public static final String R1 = JoystickButton.BUTTON_5; + /** + * Some gamepads (Xbox controllers notable) will use + * {@link JoystickAxis#LEFT_TRIGGER} instead. + */ + public static final String L2 = JoystickButton.BUTTON_6; + /** + * Some gamepads (Xbox controllers notable) will use + * {@link JoystickAxis#RIGHT_TRIGGER} instead. + */ + public static final String R2 = JoystickButton.BUTTON_7; + public static final String SELECT = JoystickButton.BUTTON_8; + public static final String START = JoystickButton.BUTTON_9; + /** + * Pressing the left analog stick. + */ + public static final String L3 = JoystickButton.BUTTON_10; + /** + * Pressing the right analog stick. + */ + public static final String R3 = JoystickButton.BUTTON_11; + /** + * Most gamepads may use {@link JoystickAxis#POV_X} instead. + */ + public static final String DPAD_LEFT = "12"; + /** + * Most gamepads may use {@link JoystickAxis#POV_X} instead. + */ + public static final String DPAD_RIGHT = "13"; + /** + * Most gamepads may use {@link JoystickAxis#POV_Y} instead. + */ + public static final String DPAD_UP = "14"; + /** + * Most gamepads may use {@link JoystickAxis#POV_Y} instead. + */ + public static final String DPAD_DOWN = "15"; + private static void initializeJoystickMappings() { if (CALIBRATION_FILE == null) @@ -199,6 +257,11 @@ public class Main extends SimpleApplication } } + public Main() + { + super(new StatsAppState(), new DebugKeysAppState()); + } + @Override public void initialize() { @@ -243,5 +306,7 @@ public class Main extends SimpleApplication // to blue geom.setMaterial(mat); // set the cube's material rootNode.attachChild(geom); // make the cube appear in the scene + + this.getStateManager().attach(new JoystickPreviewScreen()); } }