桃缶食べたい。

ソースコード

package test.input;

import static org.lwjgl.opengl.GL11.GL_BACK;
import static org.lwjgl.opengl.GL11.GL_BLEND;
import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.GL_QUADS;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
import static org.lwjgl.opengl.GL11.glBegin;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glClearColor;
import static org.lwjgl.opengl.GL11.glColor4f;
import static org.lwjgl.opengl.GL11.glCullFace;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glEnd;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.opengl.GL11.glOrtho;
import static org.lwjgl.opengl.GL11.glPopMatrix;
import static org.lwjgl.opengl.GL11.glPushMatrix;
import static org.lwjgl.opengl.GL11.glRotatef;
import static org.lwjgl.opengl.GL11.glScalef;
import static org.lwjgl.opengl.GL11.glTranslatef;
import static org.lwjgl.opengl.GL11.glVertex3f;

import java.util.ArrayList;
import java.util.List;

import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;

import test.alphablend.AlphaBlend;
import test.input.GameController.Input;
import test.monolith.v3.Texture;
import test.monolith.v3.TextureLoader;

public class InputTest {
	private static final float	TYPHOON_OUTER_ROTATE_MILLSECOND= 38000;
	private static final float	TYPHOON_ROTATE_MILLSECOND= 22000;
	private static final float	TYPHOON_INNER_ROTATE_MILLSECOND = 12000;
	private static final int	MOVE_DISTANCE_PER_SECOND = 100;

	private int			width = 1280;
	private int			height = 720;
	private int			depth = 100;
	private String		title = "Game Controllers";

	private long		time;
	private long		timeDelta;
	private long		fps;

	private Texture		textureMap;
	private Texture		textureTyphoon;
	private Texture		textureYurie;
	
	private long		actionStartTime;
	private long		actionTime;
	private float		x;
	private float		y;

	private List<GameController>	controllers;
	private int				controllerIndex;
	private GameController	controller;
	private GameController	keyboard;

	public void start() {
		try {
			//	ウインドウを生成する
			Display.setDisplayMode(new DisplayMode(width, height));
			Display.setTitle(title);
			Display.create();
		} catch(LWJGLException e) {
			e.printStackTrace();
			return;
		}

		try {
			//	OpenGL の初期設定

			//	オフスクリーンを初期化する際の背景色を指定する
			glClearColor(1f, 1f, 1f, 1f);

			//	テクスチャーを有効化する
			glEnable(GL_TEXTURE_2D);

			//	アルファブレンドを有効化する
			glEnable(GL_BLEND);

			//	ポリゴンの表示面を表のみに設定する
			glEnable(GL_CULL_FACE);
			glCullFace(GL_BACK);

			//	カメラ用の設定変更を宣言する
			glMatrixMode(GL_PROJECTION);
			//	設定を初期化する
			glLoadIdentity();
			//	視体積（目に見える範囲）を定義する
			glOrtho(0, width, 0, height, 0, depth);

			//	物体モデル用の設定変更を宣言する
			glMatrixMode(GL_MODELVIEW);

			init();

			while (!Display.isCloseRequested()) {
				//	オフスクリーンを初期化する
				glClear(GL_COLOR_BUFFER_BIT);

				//	キー入力を処理する
				updateControllers();

				//	FPS を計算する
				calcFps();

				update();

				//	オフスクリーンに描画する
				render();

				//	オフスクリーンをスクリーンに反映する
				Display.update();
			}
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			terminate();
			Display.destroy();
		}
	}

	private void updateControllers() {
		//	すべてのジョイパッドの入力を取得する
		Controllers.poll();

		while (Controllers.next()) {
			//	現在利用しているジョイパッドのイベントであれば、入力状況を更新する
			if (controller.isOwner(Controllers.getEventSource())) {
				controller.update();
			}
		}

		//	キーボードは常に入力状況を更新する
		keyboard.update();
	}

	private void init() throws Exception {
		time = getMillisecond();
		fps = 0;

		//	ファイルのパス指定で画像を読み込む
		textureMap = new TextureLoader().loadTexture("images/map.png");
		textureTyphoon = new TextureLoader().loadTexture("images/typhoon.png");
		textureYurie = new TextureLoader().loadTexture("images/yurie.png");

		//	ゆりえ様を初期化する
		actionStartTime = actionTime = getMillisecond();
		x = 600;
		y = 300;

		//	コントローラーを用意する
		controllers = new ArrayList<GameController>();
		try {
			Controllers.create();
			for (int i = 0; i < Controllers.getControllerCount(); i++) {
				Controller	controller = Controllers.getController(i);

				System.out.println("Detected controller(" + i + "): " + controller.getName());
				controllers.add(new JoyStick(controller));
			}
		} catch (LWJGLException e) {
			e.printStackTrace();
		}
		keyboard = new PcKeyboard();
		controllers.add(keyboard);

		controllerIndex = controllers.size() - 1;
		controller = controllers.get(controllerIndex);
	}
	
	private void terminate() {
		if (textureMap != null) textureMap.dispose();
		if (textureTyphoon != null) textureTyphoon.dispose();
		if (textureYurie != null) textureYurie.dispose();
	}

	private void update() {
		//	GameController.isPressing() ではなく、最初に押して離されたキーをイベントとして取得する
		if (keyboard.getKeyEvent() == Input.SELECT) {
			controllerIndex = (controllerIndex + 1) % controllers.size();
			controller = controllers.get(controllerIndex);
		}
		
		//	移動の方向と大きさを判定する
		int			moveSize = 1;
		int			moveX = 0;
		int			moveY = 0;

		if (controller.isPressing(Input.UP)) {
			moveY = 1;
		} else if (controller.isPressing(Input.DOWN)) {
			moveY = -1;
		}

		if (controller.isPressing(Input.RIGHT)) {
			moveX = 1;
		} else if (controller.isPressing(Input.LEFT)) {
			moveX = -1;
		}

		if (controller.isPressing(Input.CROSS)) {
			moveSize = 3;
		}

		//	移動する
		long	now = getMillisecond();
		long	delta = now - actionTime;
		int		move = (int)(MOVE_DISTANCE_PER_SECOND * (delta / 1000f));

		x += (moveX * move * moveSize);
		y += (moveY * move * moveSize);
		actionTime = now;

		//	FPS を調整する
		Display.sync(60);
	}

	private void render() {
		//	設定を初期化する
		glLoadIdentity();

		drawPicture(textureMap, 0, height);
	
		//	行列スタックに現在の行列を退避させ、新しい行列に対してモデルビュー変換を開始する
		glPushMatrix();

		//	ゆりえ様の中心が原点となるよう座標軸を移動する
		glTranslatef(x, y, 0);

		AlphaBlend.Screen.config(textureTyphoon);
		drawTyphoon(TYPHOON_OUTER_ROTATE_MILLSECOND, 0.5f, 1.3f);
		drawTyphoon(TYPHOON_ROTATE_MILLSECOND, 1f, 1f);
		drawTyphoon(TYPHOON_INNER_ROTATE_MILLSECOND, 0.7f, 0.7f);

		AlphaBlend.AlphaBlend.config(textureYurie);
		glColor4f(1f, 1f, 1f, 1f);
		drawPicture(textureYurie, textureYurie.getWidth() / -2, textureYurie.getHeight() / 2);
		
		//	行列スタックからもとの行列を取り出す
		glPopMatrix();

	}
	
	private void drawTyphoon(float rotateTime, float alpha, float scale) {
		glPushMatrix();

		//	Z 軸を中心にを回転させる
		float	angle = ((getMillisecond() - actionStartTime) % rotateTime) / rotateTime * 360;
		glRotatef(angle, 0, 0, 1);

		//	スケールを設定する
		glScalef(scale, scale, scale);

		glColor4f(1f, 1f, 1f, alpha);
		
		drawPicture(textureTyphoon, textureTyphoon.getWidth() / -2, textureTyphoon.getHeight() / 2);

		glPopMatrix();
	}

	private void drawPicture(Texture texture, float x, float y) {
		//	テクスチャをバインドする
		texture.bind();

		glBegin(GL_QUADS);

		float	x2 = x + texture.getWidth();
		float	y2 = y - texture.getHeight();

		texture.point(texture.getWidth(), 0);
		glVertex3f(x2, y, 0);

		texture.point(0, 0);
		glVertex3f(x, y, 0);

		texture.point(0, texture.getHeight());
		glVertex3f(x, y2, 0);
	
		texture.point(texture.getWidth(), texture.getHeight());
		glVertex3f(x2, y2, 0);
		
		glEnd();
	}

	private void calcFps() {
		long	now = getMillisecond();

		//	前のフレームからの経過時間を求め、timeDelta に足す
		timeDelta += now - time;
		time = now;

		if (1000 <= timeDelta) {
			//	timeDelta が 1 秒を上回ったら、FPS をリセットする
			timeDelta -= 1000;
			Display.setTitle(title + "(" + fps + "fps), controller(" + controllerIndex + "): " + controller.getName());
			fps = 1;
		} else {
			fps++;
		}
	}
	
	public static long getMillisecond() {
		//	現在の時間をミリ秒で返す
		return (Sys.getTime() * 1000) / Sys.getTimerResolution();
	}

	public static void main(String[] args) {
		new InputTest().start();
	}
}

package test.input;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;

public class PcKeyboard extends GameController {
	//	デフォルトのキーコンフィグ
	private static final Map<Integer, Input>	DEFAULT_KEY_CONFIGS;
	static {
		Map<Integer, Input>	keyConfigs = new HashMap<Integer, Input>();

		keyConfigs.put(Keyboard.KEY_UP, Input.UP);
		keyConfigs.put(Keyboard.KEY_DOWN, Input.DOWN);
		keyConfigs.put(Keyboard.KEY_RIGHT, Input.RIGHT);
		keyConfigs.put(Keyboard.KEY_LEFT, Input.LEFT);
		keyConfigs.put(Keyboard.KEY_Z, Input.CIRCLE);
		keyConfigs.put(Keyboard.KEY_X, Input.CROSS);
		keyConfigs.put(Keyboard.KEY_F1, Input.SELECT);

		DEFAULT_KEY_CONFIGS = Collections.unmodifiableMap(keyConfigs);
	}

	public PcKeyboard() {
		super(DEFAULT_KEY_CONFIGS);
	}

	public void update() {
		//	キーボードの入力をすべて取得する
		while (Keyboard.next()) {
			boolean		isPressed = Keyboard.getEventKeyState();
			int			keyCode = Keyboard.getEventKey();
			Input		input = getInput(keyCode);
			
			//	キーボードからの入力で、論理キーの状態を更新する
			if (input != null) {
				setKeyStatus(input, isPressed);
			}
		}
	}

	@Override
	public String getName() {
		return "Keyboard";
	}

	@Override
	public boolean isOwner(Controller controller) {
		return false;
	}
	
}

package test.input;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.lwjgl.input.Controller;

public class JoyStick extends GameController {
	//	デフォルトのキーコンフィグ
	private static final Map<Integer, Input>	DEFAULT_KEY_CONFIGS;
	static {
		Map<Integer, Input>	keyConfigs = new HashMap<Integer, Input>();

		keyConfigs.put(3, Input.CIRCLE);
		keyConfigs.put(2, Input.CROSS);
		DEFAULT_KEY_CONFIGS = Collections.unmodifiableMap(keyConfigs);
	}

	private final Controller	controller;

	public JoyStick(Controller controller) {
		super(DEFAULT_KEY_CONFIGS);
		this.controller = controller;
	}

	@Override
	public void update() {
		//	ボタンの入力状態を反映する
		for (int keyCode: keyCodes()) {
			Input	input = getInput(keyCode);
			boolean	isPressed = false;

			if (keyCode < controller.getButtonCount()) {
				isPressed = controller.isButtonPressed(keyCode);
			}
			setKeyStatus(input, isPressed);
		}
		
		float	xAxis = controller.getXAxisValue();
		float	yAxis = controller.getYAxisValue();

		//	アナログスティックの X 軸方向の入力状態を反映する
		boolean	isLeftPressing = false;
		boolean	isRightPressing = false;
		if (xAxis < 0) {
			isLeftPressing = true;
		} else if (0 < xAxis) {
			isRightPressing = true;
		}
		setKeyStatus(Input.LEFT, isLeftPressing);
		setKeyStatus(Input.RIGHT, isRightPressing);

		//	アナログスティックの Y 軸方向の入力状態を反映する
		boolean	isUpPressing = false;
		boolean	isDownPressing = false;
		if (yAxis < 0) {
			isUpPressing = true;
		} else if (0 < yAxis) {
			isDownPressing = true;
		}
		setKeyStatus(Input.UP, isUpPressing);
		setKeyStatus(Input.DOWN, isDownPressing);
	}

	public boolean isOwner(Controller controller) {
		return (this.controller == controller);
	}

	@Override
	public String getName() {
		return controller.getName();
	}

}

package test.input;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.lwjgl.input.Controller;

public abstract class GameController {
	/**
	 *	論理キーを表す enum
	 *	ゲームコントローラーが持つ○ボタン（決定ボタン）や×ボタン（キャンセルボタン）などに該当する
	 */
	public enum Input {
		UP,
		DOWN,
		RIGHT,
		LEFT,
		
		CIRCLE,
		CROSS,
		
		SELECT;
	}

	private final Map<Integer, Input>	keyConfigs;
	private final Map<Input, Boolean>	keyStatus = new HashMap<Input, Boolean>();

	private Input				keyEvent;
	
	public GameController(Map<Integer, Input> keyConfigs) {
		this.keyConfigs = new HashMap<Integer, Input>();

		//	デフォルトのキーコンフィグとして、引数　keyConfigs　の内容を設定する
		for (int keyCode: keyConfigs.keySet()) {
			setKeyConfig(keyCode, keyConfigs.get(keyCode));
		}
	}

	/**
	 *	キーの入力状態をチェックし、状態を更新する
	 */
	public abstract void update();

	/**
	 *	引数に渡されたジョイスティックがこのゲームコントローラーのものなら true を、そうでなければ false を返す
	 */
	public abstract boolean isOwner(Controller controller);
	
	/**
	 *	このゲームコントローラーの名前を返す
	 */
	public abstract String getName();

	/**
	 *	引数に渡されたキーコードに割り当てられた論理キーを返す
	 */
	protected Input getInput(int keyCode) {
		return keyConfigs.get(keyCode);
	}

	/**
	 *	論理キーに割り当てられているすべてのキーコードの Set を返す
	 */
	protected Set<Integer> keyCodes() {
		return keyConfigs.keySet();
	}
	
	/**
	 *	引数に渡されたキーコードに、論理キーを割り当てる
	 */
	public void setKeyConfig(int keyCode, Input input) {
		keyConfigs.put(keyCode, input);
	}
	
	/**
	 *	引数に渡された論理キーの入力状態を設定する
	 */
	protected void setKeyStatus(Input input, boolean isPressing) {
		//	論理キーが今まで押されていて、かつ離された場合、論理キーの入力イベントが完了したものとして保持しておく
		//	ただし、保持できる入力イベントは、最初の 1 つのみとする
		if ((isPressing(input)) && (!isPressing) && (this.keyEvent == null)) {
			this.keyEvent = input;
		}
		
		//	論理キーの入力状態を設定する
		keyStatus.put(input, isPressing);
	}

	/**
	 *	引数に渡された論理キーの入力状態を返す
	 */
	public boolean isPressing(Input input) {
		//	現在押されていれば true を、そうでなければ false を返す
		Boolean	isPressing = keyStatus.get(input);
		
		if (isPressing == null) {
			return false;
		} else {
			return isPressing.booleanValue();
		}
	}

	/**
	 *	論理キーの入力イベントを返す
	 *	入力イベントとは、キーが押された後に離された時点で発生する。
	 *	また、入力イベントは最初に発生したものを１つだけ保するものとする。
	 */
	public Input getKeyEvent() {
		Input	keyEvent = this.keyEvent;

		//	論理キーの入力イベントは、取得したら空にする
		this.keyEvent = null;
		
		return keyEvent;
	}

}

プログラムの使い方

キーボードからの入力

キー入力の取得

//	矢印上キーが押されているか調べる
if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
	...
}

//	Ctrl + Z キーが押されているか調べる
if ((Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)) && (Keyboard.isKeyDown(Keyboard.KEY_Z))) {
	...
}

すべてのキー入力を取得する

//	キーボードからの入力を、先頭から１つずつ取り出していく
while (Keyboard.next()) {
	//	キーが押されているか、離されているかを調べる
	boolean		isPressed = Keyboard.getEventKeyState();
	//	押されたキーのキーコードを取得する
	int			keyCode = Keyboard.getEventKey();
	...
}

ジョイスティックからの入力

jinput

ジョイスティックの検出

try {
	//	ジョイスティックを検出する
	Controllers.create();
	//	検出したジョイスティックを一覧表示する
	for (int i = 0; i < Controllers.getControllerCount(); i++) {
		Controller	controller = Controllers.getController(i);

		System.out.println("Detected controller(" + i + "): " + controller.getName());
		...
	}
} catch (LWJGLException e) {
	e.printStackTrace();
}

ボタンからの入力

isPressed = controller.isButtonPressed(keyCode);

public class JoyStick extends GameController {
	//	デフォルトのキーコンフィグ
	private static final Map<Integer, Input>	DEFAULT_KEY_CONFIGS;
	static {
		Map<Integer, Input>	keyConfigs = new HashMap<Integer, Input>();

		keyConfigs.put(3, Input.CIRCLE);
		keyConfigs.put(2, Input.CROSS);
		DEFAULT_KEY_CONFIGS = Collections.unmodifiableMap(keyConfigs);
	}
...

//	すべてのジョイパッドの入力イベントを取得する
Controllers.poll();

while (Controllers.next()) {
	//	入力イベントの発生した（入力された）コントローラーを取得する
	Controller	inputController = Controllers.getEventSource()
			
	//	入力イベントがボタンの入力によるものかを返す
	boolean		isButtonEvent = Controllers.isEventButton();

	//	入力イベントがアナログスティックの入力によるものかを返す
	boolean		isAxisEvent = Controllers.isEventAxis();
}

アナログスティックからの入力

float	xAxis = controller.getXAxisValue();
float	yAxis = controller.getYAxisValue();

GameController クラスの構築

キーボード、ジョイスティックの抽象化

public void update() {
	//	キーボードの入力をすべて取得する
	while (Keyboard.next()) {
		boolean		isPressed = Keyboard.getEventKeyState();
		int			keyCode = Keyboard.getEventKey();
		Input		input = getInput(keyCode);

		//	キーボードからの入力で、論理キーの状態を更新する
		if (input != null) {
			setKeyStatus(input, isPressed);
		}
	}
}

@Override
public void update() {
	//	ボタンの入力状態を反映する
	for (int keyCode: keyCodes()) {
		...
		boolean	isPressed = false;

		if (keyCode < controller.getButtonCount()) {
			isPressed = controller.isButtonPressed(keyCode);
		}
		...
	}
	
	float	xAxis = controller.getXAxisValue();
	float	yAxis = controller.getYAxisValue();
...

論理キーの構築

//	×ボタンが押されている間はダッシュしているものとみなし、移動量を 3 倍にする
if (controller.isPressing(Input.CROSS)) {
	moveSize = 3;
}

public GameController(Map<Integer, Input> keyConfigs) {
	this.keyConfigs = new HashMap<Integer, Input>();

	//	デフォルトのキーコンフィグとして、引数 keyConfigs の内容を設定する
	for (int keyCode: keyConfigs.keySet()) {
		setKeyConfig(keyCode, keyConfigs.get(keyCode));
	}
}

論理キーの入力イベント

	/**
	 *	引数に渡された論理キーの入力状態を設定する
	 */
	protected void setKeyStatus(Input input, boolean isPressing) {
		//	論理キーが今まで押されていて、かつ離された場合、論理キーの入力イベントが完了したものとして保持しておく
		//	ただし、保持できる入力イベントは、最初の 1 つのみとする
		if ((isPressing(input)) && (!isPressing) && (this.keyEvent == null)) {
			this.keyEvent = input;
		}
		...
	}

渦巻く雲を表現する

おしまい