桃缶食べたい。

ソースコード

package test.secretBase;

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 static test.secretBase.Flower.LIFE_MILLISECOND;

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

import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;

import test.monolith.v3.Texture;
import test.monolith.v3.TextureLoader;
import test.alphablend.AlphaBlend;

public class SecretBase {
	private int				width = 1280;
	private int				height = 720;
	private int				depth = 100;
	private String		   title = "SecretBase";
	
	private long			time;
	private long			timeDelta;
	private long			fps;
	
	private Texture			texture;
	private List<Flower>	flowers;
	private int				   flowerCount;
	private long				 flowerCreatedTime;
	private float				 flowerCreatedDelta;
	private boolean			isReversed;

	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);
				
				//	キー入力を処理する
				update();
				
				//	オフスクリーンに描画する
				render();

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

	private void init() throws Exception {
		time = getMillisecond();
		fps = 0;
		
		flowerCount = 300;
		flowers = new ArrayList<Flower>();
		flowerCreatedTime = getMillisecond();
		isReversed = false;
		
		//	ファイルのパス指定で画像を読み込む
		texture = new TextureLoader().loadTexture("images/flower.png");
	}
	
	private void terminate() {
		if (texture != null) texture.dispose();
	}

	private void update() {
		calcFps();
		
		updateFlowers();

		while (Keyboard.next()) {

			if ((Keyboard.getEventKey() == Keyboard.KEY_F1) && (Keyboard.getEventKeyState())) {
				isReversed = !isReversed;
			} else if ((Keyboard.getEventKey() == Keyboard.KEY_F2) && (Keyboard.getEventKeyState())) {
				flowerCount -= 50;
				if (flowerCount < 0) {
					flowerCount = 0;
				}
			} else if ((Keyboard.getEventKey() == Keyboard.KEY_F3) && (Keyboard.getEventKeyState())) {
				flowerCount += 50;
			} else {
				continue;
			}
			break;
		}
		
		//	FPS を調整する
		Display.sync(60);
	}

	private void updateFlowers() {
		int		lowerY = 0 - (texture.getHeight() / 2);
		int		upperY = height + (texture.getHeight() / 2);
		
		for (Flower flower: flowers.toArray(new Flower[] {})) {
			if ((flower.getY() < lowerY) || (upperY < flower.getY())) {
				//	ウィンドウの外に出た花は削除する
				flowers.remove(flower);
			} else {
				//	花の状態を更新する
				flower.update(upperY - lowerY, isReversed);
			}
		}

		//	前フレームからの経過時間から、必要な数だけ花を生成する
		float	createInterval = LIFE_MILLISECOND / flowerCount;
		long	now = getMillisecond();

		flowerCreatedDelta += (now - flowerCreatedTime);
		while (createInterval <= flowerCreatedDelta) {
			if (flowers.size() < flowerCount) {
				int		x = (int)(Math.random() * width);
				int		y = (isReversed)? lowerY: upperY;
				float	scale = random(0.3f, 1f) * random(0.3f, 1f);

				//	オレンジ ~ 赤 ~ 紫の中からランダムで色を作る
				float	rand = random(0f, 1.4f);
				float	r = 1f;
				float	g = (1f < rand)? rand -1f: 0f;
				float	b = (rand <= 1f)? rand: 0f; 
				
				//	ランダムで、色を白に近づける
				rand = random(0.3f, 1f);
				r = r + ((1f - r) * rand);
				g = g + ((1f - g) * rand);
				b = b + ((1f - b) * rand);

				//	ランダムで、色を黒に近づける
				rand = random(0.95f, 1f);
				r *= rand;
				g *= rand;
				b *= rand;

				Flower	flower = new Flower(); 
				
				flower.setPosition(x, y);
				flower.setScale(scale);
				flower.setColor(r, g, b);
				flower.init();
				flowers.add(flower);
			}
			flowerCreatedDelta -= createInterval;
		}
		flowerCreatedTime = now;
	}

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

		//	アルファブレンドで表示する
		AlphaBlend.AlphaBlend.config(texture);

		for (Flower flower: flowers) {
			//	行列スタックに現在の行列を退避させ、新しい行列に対してモデルビュー変換を開始する
			glPushMatrix();

			//	isReversed に応じて花の色を RGB カラーとグレースケールで切り替える
			if (isReversed) {
				glColor4f(flower.getR(), flower.getG(), flower.getB(), 1f);
			} else {
				glColor4f(flower.getBrightness(), flower.getBrightness(), flower.getBrightness(), 1f);
			}

			//	花の中心が原点となるよう座標軸を移動する
			glTranslatef(flower.getX(), flower.getY(), 0);

			//	花毎ののスケールを設定する
			glScalef(flower.getScale(), flower.getScale(), flower.getScale());
			
			//	Z 軸を中心に花を回転させる
			glRotatef(flower.getAngle(), 0, 0, 1);

			drawPicture(texture, texture.getWidth() / -2, texture.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, " + flowers.size() + " / " + flowerCount + " flowers)");
			fps = 1;
		} else {
			fps++;
		}
	}
	
	private float random(float min, float max) {
		//	min から max までの間で乱数を生成して返す
		float	dist = max - min;
		
		return (float)(Math.random() * dist + min);
	}
	
	public static long getMillisecond() {
		//	現在の時間をミリ秒で返す
		return (Sys.getTime() * 1000) / Sys.getTimerResolution();
	}

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

package test.secretBase;

public class Flower {
	static final float			LIFE_MILLISECOND = 8000f;
	private static final float	ROTATE_MILLISECOND = 5000f;

	private float	x;
	private float	y;
	private float	scale;
	private float	r;
	private float	g;
	private float	b;
	private float	brightness;
	
	private long	time;
	
	private long	start;
	private float	angle;
	
	public void init() {
		start = SecretBase.getMillisecond();
	}

	public void update(int distance, boolean isReversed) {
		if (time <= 0) {
			time = SecretBase.getMillisecond();
			return;
		}
		
		//	前フレームからの経過時間から、このフレームでの移動距離を求める
		long	now = SecretBase.getMillisecond();
		long	delta = now - time;
		float	move = delta / LIFE_MILLISECOND * distance;

		//	この花の生成時間からの経過時間から、回転する角度を求める
		angle = ((now - start) % ROTATE_MILLISECOND / ROTATE_MILLISECOND) * 360f;

		//	isReversed に応じた方向へ移動・回転する
		if (isReversed) {
			y += move;
		} else {
			y -= move;
			angle = 360f - angle;
		}
		
		time = now;
	}

	public float getX() {
		return x;
	}

	public float getY() {
		return y;
	}
	
	public void setPosition(float x, float y) {
		this.x = x;
		this.y = y;
	}

	public float getScale() {
		return scale;
	}

	public float getAngle() {
		return angle;
	}

	public void setColor(float r, float g, float b) {
		this.r = r;
		this.g = g;
		this.b = b;

		//	NTSC 係数による加重平均法でグレースケールに変換後の輝度を求める
		this.brightness = (float)(0.298912 * r + 0.586611 * g + 0.114478 * b);
	}
	
	public float getR() {
		return r;
	}

	public float getG() {
		return g;
	}

	public float getB() {
		return b;
	}

	public float getBrightness() {
		return brightness;
	}

	public void setScale(float scale) {
		this.scale = scale;
	}
	
}

プログラムの使い方

タイマーの種類と精度

java.lang.System.currentTimeMillis()

java.lang.System.nanoTime()

org.lwjgl.Sys.getTime()

public static long getMillsecond() {
	//	現在の経過時間をミリ秒で返す
	return (Sys.getTime() * 1000) / Sys.getTimerResolution();
}

FPS

FPS を計算する

//	現在の時間を求める
long	now = getMillsecond();

//	前のフレームからの経過時間を求め、timeDelta に足す
timeDelta += now - time;
//	次のフレームでの経過時間算出のため、現在の時間を覚えておく
time = now;

//	timeDelta が 1 秒を上回ったら、FPS をリセットする
if (1000 <= timeDelta) {
	timeDelta -= 1000;
	//	ウインドウのタイトルバーに FPS を表示する
	Display.setTitle(title + "(" + fps + "fps, " + flowers.size() + " / " + flowerCount + " flowers)");
	fps = 1;
} else {
	//	FPS を１増やす
	fps++;
}

FPS を調整する

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

ポリゴンをアニメーションさせる

//	１度目の時間測定をする
if (time <= 0) {
time = SecretBase.getMillsecond();
	return;
}

//	２度目の時間測定をする
long	now = SecretBase.getMillsecond();

//	経過時間を計算する
long	delta = now - time;

//	delta の大きさに応じてポリゴンの移動距離を計算する
float	move = delta / LIFE_MILLSECOND * distance;

//	次回の処理のために、基準となる時間（１度目の測定時間）を現在の時間とする
time = now;

サンプルプログラムのその他のポイント

Z 軸を中心にポリゴンを回転させる

for (Flower flower: flowers) {
	//	モデルビュー変換中の行列を、行列スタックに退避させる
	glPushMatrix();

	...

	//	座標の中心を花の中央に移動する
	glTranslatef(flower.getX(), flower.getY(), 0);

	...
			
	//	Z 軸を中心にポリゴンを回転させる
	glRotatef(flower.getAngle(), 0, 0, 1);
	
	//	花のポリゴンを描画する
	drawPicture(texture, texture.getWidth() / -2, texture.getHeight() / 2);

	//	退避させていた元のモデルビュー変換の行列を、行列スタックから取り出す
	glPopMatrix();
}

ポリゴンの色をランダムに補正する

//	オレンジ ~ 赤 ~ 紫の中からランダムで色を作る
float	rand = random(0f, 1.4f);
float	r = 1f;
float	g = (1f < rand)? rand -1f: 0f;
float	b = (rand <= 1f)? rand: 0f; 

//	ランダムで、色を白に近づける
rand = random(0.3f, 1f);
r = r + ((1f - r) * rand);
g = g + ((1f - g) * rand);
b = b + ((1f - b) * rand);

//	ランダムで、色を黒に近づける
rand = random(0.95f, 1f);
r *= rand;
g *= rand;
b *= rand;

Flower	flower = new Flower(); 

flower.setColor(r, g, b);

色情報をグレースケールに変換する

//	NTSC 係数による加重平均法でグレースケールに変換後の輝度を求める
this.brightness = (float)(0.298912 * r + 0.586611 * g + 0.114478 * b);

終わり。