桃缶食べたい。

ソースコード

package test.monolith.v3;

import static org.lwjgl.opengl.GL11.GL_BACK;
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.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.glRotatef;
import static org.lwjgl.opengl.GL11.glScalef;
import static org.lwjgl.opengl.GL11.glTranslatef;

import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;

import test.monolith.v1.Direction;

public class TextureMonolith {
	private int			width = 450;
	private int			height = 320;
	private int			depth = 300;

	private float		   xAngle = 0;
	private float		   yAngle = 0;
	private Direction	   input = null;
	
	private Texture			texture;

	public void start() {
		try {
			//	ウインドウを生成する
			Display.setDisplayMode(new DisplayMode(width, height));
			Display.setTitle("Textured Monolith");
			Display.create();
		} catch(LWJGLException e) {
			e.printStackTrace();
			return;
		}
		
		try {
			//	OpenGL の初期設定
			
			//	テクスチャーを有効化する
			glEnable(GL_TEXTURE_2D);

			//	ポリゴンの表示面を表のみに設定する
			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 {
		//	ファイルのパス指定で画像を読み込む
		texture = new TextureLoader().loadTexture("images/texture.png");

		//	クラスパスから画像を検索して読み込む
//		texture = new TextureLoader().loadTexture("images/texture.png", this.getClass().getClassLoader());
	}
	
	private void terminate() {
		if (texture != null) texture.dispose();
	}

	private void update() {
		input = Direction.getPressing();
		
		if (input != null) {
			xAngle = input.rotateXAngle(xAngle);
			yAngle = input.rotateYAngle(yAngle);
		}
	}

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

		//	画面中央の座標を (0, 0, 0) とするよう座標系を移動する
		glTranslatef(width / 2f, height / 2f, depth / -2f);

		//	座標のスケールを指定する
		//	ここで指定した x, y, z 毎の係数が、次に指定する座標にそれぞれ掛けられる
		glScalef(30f, 30f, 30f);

		glRotatef(xAngle, 0, 1, 0);	//	y 軸を中心に xAngle 度回転させる
		glRotatef(yAngle, 1, 0, 0);	//	x 軸を中心に yAngle 度回転させる
		
		//	テクスチャをバインドする
		texture.bind();
		
		glBegin(GL_QUADS);

		glColor4f(1f, 1f, 1f, 1f);
		
		for (Face face: Face.values()) {
			face.draw(texture, 1f);
		}
		
		glEnd();
	}

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

}

package test.monolith.v3;

import static test.monolith.v1.Point.P_BACK_BOTTOM_LEFT;
import static test.monolith.v1.Point.P_BACK_BOTTOM_RIGHT;
import static test.monolith.v1.Point.P_BACK_TOP_LEFT;
import static test.monolith.v1.Point.P_BACK_TOP_RIGHT;
import static test.monolith.v1.Point.P_FRONT_BOTTOM_LEFT;
import static test.monolith.v1.Point.P_FRONT_BOTTOM_RIGHT;
import static test.monolith.v1.Point.P_FRONT_TOP_LEFT;
import static test.monolith.v1.Point.P_FRONT_TOP_RIGHT;
import static test.monolith.v3.Bounds.B_BACK;
import static test.monolith.v3.Bounds.B_BOTTOM;
import static test.monolith.v3.Bounds.B_FRONT;
import static test.monolith.v3.Bounds.B_LEFT;
import static test.monolith.v3.Bounds.B_RIGHT;
import static test.monolith.v3.Bounds.B_TOP;
import test.monolith.v1.Point;

public enum Face {
	F_FRONT(new Point[] {
			P_FRONT_TOP_RIGHT,
			P_FRONT_TOP_LEFT,
			P_FRONT_BOTTOM_LEFT,
			P_FRONT_BOTTOM_RIGHT
	}, B_FRONT),
	F_BACK(new Point[] {
			P_BACK_TOP_LEFT,
			P_BACK_TOP_RIGHT,
			P_BACK_BOTTOM_RIGHT,
			P_BACK_BOTTOM_LEFT,
	}, B_BACK),
	F_LEFT(new Point[] {
			P_FRONT_TOP_LEFT,
			P_BACK_TOP_LEFT,
			P_BACK_BOTTOM_LEFT,
			P_FRONT_BOTTOM_LEFT
	}, B_LEFT),
	F_RIGHT(new Point[] {
			P_BACK_TOP_RIGHT,
			P_FRONT_TOP_RIGHT,
			P_FRONT_BOTTOM_RIGHT,
			P_BACK_BOTTOM_RIGHT
	}, B_RIGHT),
	F_TOP(new Point[] {
			P_BACK_TOP_RIGHT,
			P_BACK_TOP_LEFT,
			P_FRONT_TOP_LEFT,
			P_FRONT_TOP_RIGHT			
	}, B_TOP),
	F_BOTTOM(new Point[] {
			P_FRONT_BOTTOM_RIGHT,
			P_FRONT_BOTTOM_LEFT,
			P_BACK_BOTTOM_LEFT,
			P_BACK_BOTTOM_RIGHT
	}, B_BOTTOM);

	private final Point[]  points;
	private final Bounds   bounds;
	
	private Face(Point[] points, Bounds bounds) {
		this.points = points;
		this.bounds = bounds;
	}

	public void draw(Texture texture, float alpha) {
		bounds.pointTopRight(texture);
		points[0].point();
		bounds.pointTopLeft(texture);
		points[1].point();

		bounds.pointBottomLeft(texture);
		points[2].point();
		bounds.pointBottomRight(texture);
		points[3].point();
	}

}

package test.monolith.v3;

public enum Bounds {
	B_FRONT(80, 80, 240, 400),
	B_BACK(320, 80, 480, 400),
	B_LEFT(0, 80, 80, 400),
	B_RIGHT(240, 80, 320, 400),
	B_TOP(80, 0, 240, 80),
	B_BOTTOM(80, 400, 240, 480)
	;
	
	private final int		x1;
	private final int		y1;
	private final int		x2;
	private final int		y2;
	
	private Bounds(int x1, int y1, int x2, int y2) {
		this.x1 = x1;
		this.y1 = y1;
		this.x2 = x2;
		this.y2 = y2;
	}

	public void pointTopLeft(Texture texture) {
		texture.point(x1, y1);
	}

	public void pointTopRight(Texture texture) {
		texture.point(x2, y1);
	}

	public void pointBottomLeft(Texture texture) {
		texture.point(x1, y2);
	}

	public void pointBottomRight(Texture texture) {
		texture.point(x2, y2);
	}
}

/**
 * Copyright (c) 2002-2008 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 test.monolith.v3;

import static org.lwjgl.opengl.GL11.GL_LINEAR;
import static org.lwjgl.opengl.GL11.GL_RGB;
import static org.lwjgl.opengl.GL11.GL_RGBA;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER;
import static org.lwjgl.opengl.GL11.GL_UNSIGNED_BYTE;
import static org.lwjgl.opengl.GL11.glBindTexture;
import static org.lwjgl.opengl.GL11.glGenTextures;
import static org.lwjgl.opengl.GL11.glTexImage2D;
import static org.lwjgl.opengl.GL11.glTexParameteri;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.util.Hashtable;

import javax.imageio.ImageIO;

import org.lwjgl.BufferUtils;

public class TextureLoader {
	private final ColorModel		glAlphaColorModel = new ComponentColorModel(
			ColorSpace.getInstance(ColorSpace.CS_sRGB),
			new int[] {8,8,8,8},
			true,
			false,
			ComponentColorModel.TRANSLUCENT,
			DataBuffer.TYPE_BYTE);
	private final ColorModel		glColorModel = new ComponentColorModel(
			ColorSpace.getInstance(ColorSpace.CS_sRGB),
			new int[] {8,8,8,0},
			false,
			false,
			ComponentColorModel.OPAQUE,
			DataBuffer.TYPE_BYTE);
	private final IntBuffer			textureIDBuffer = BufferUtils.createIntBuffer(1);

	/**
	 *	テクスチャーIDを生成する
	 */
	private int createTextureID() {
		glGenTextures(textureIDBuffer);

		return textureIDBuffer.get(0);
	}

	/**
	 *	指定されたパスの画像ファイルをテクスチャーに変換して返す
	 */
	public Texture loadTexture(String imagePath) throws IOException {
		return loadTexture(ImageIO.read(new FileInputStream(imagePath)));
	}

	/**
	 *	指定されたパスの画像ファイルを、指定された ClassLoader で探して、テクスチャーに変換して返す
	 */
	public Texture loadTexture(String imagePath, ClassLoader classLoader) throws IOException {
		return loadTexture(ImageIO.read(classLoader.getResourceAsStream(imagePath)));
	}

	/**
	 *	BufferedImage をテクスチャーに変換して返す
	 */
	public Texture loadTexture(BufferedImage image) throws IOException {
		return loadTexture(image, GL_TEXTURE_2D, GL_RGBA, GL_LINEAR, GL_LINEAR);
	}

	private Texture loadTexture(BufferedImage image, int target, int dstPixelFormat, int minFilter, int magFilter) throws IOException {
		//	テクスチャー ID を生成する
		int		textureID = createTextureID();
		Texture	texture = new Texture(target, textureID);
		
		texture.setWidth(image.getWidth());
		texture.setHeight(image.getHeight());

		//	glTexImage2D() の対象となるテクスチャー ID をバインドする
		glBindTexture(target, textureID);

		//	アルファ値の有無を確認する
		int		srcPixelFormat;

		if (image.getColorModel().hasAlpha()) {
			srcPixelFormat = GL_RGBA;
		} else {
			srcPixelFormat = GL_RGB;
		}

		//	BufferedImage をテクスチャー用のバイト配列に変換する 
		ByteBuffer	textureBuffer = convertImageData(image, texture);

		//	画像の拡大・縮小時の補間方法を設定する
		if (target == GL_TEXTURE_2D) {
			glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter);
			glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
		}

		//	バイト配列と色情報のフォーマットからテクスチャーを生成する
		glTexImage2D(target,
					  0,
					  dstPixelFormat,
					  get2Fold(image.getWidth()),
					  get2Fold(image.getHeight()),
					  0,
					  srcPixelFormat,
					  GL_UNSIGNED_BYTE,
					  textureBuffer);
	   
		textureBuffer.clear();

		return texture;
	}

	/**
	 *	指定さえれた値より大きい 2 べき乗を求める
	 */
	private static int get2Fold(int fold) {
		int ret = 2;

		while (ret < fold) {
			ret *= 2;
		}
		return ret;
	}

	/**
	 *	テクスチャーの元データとなるバイト配列をつくり、BufferedImage　を描画して返す
	 */
	private ByteBuffer convertImageData(BufferedImage bufferedImage, Texture texture) {
		ByteBuffer		imageBuffer;
		WritableRaster	raster;
		BufferedImage	texImage;

		int				texWidth = texture.getTextureWidth();
		int				texHeight = texture.getTextureHeight();

		if ((texWidth <= 0) || (texHeight <= 0)) {
			texWidth = 2;
			texHeight = 2;

			//	テクスチャーの大きさは 2 のべき乗でなければならないため、画像本来の大きさ以上で縦横の長さを計算する
			while (texWidth < bufferedImage.getWidth()) {
				texWidth *= 2;
			}
			while (texHeight < bufferedImage.getHeight()) {
				texHeight *= 2;
			}
			
			texture.setTextureHeight(texHeight);
			texture.setTextureWidth(texWidth);
		}

		//	テクスチャーの元となるデータを作成する
		//	変換する画像がアルファ値を含むかどうかを、テクスチャーのデータ形式に反映させる
		if (bufferedImage.getColorModel().hasAlpha()) {
			raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, texWidth, texHeight, 4, null);
			texImage = new BufferedImage(glAlphaColorModel, raster, false, new Hashtable());
		} else {
			raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, texWidth, texHeight, 3, null);
			texImage = new BufferedImage(glColorModel, raster, false, new Hashtable());
		}

		//	変換する画像のアルファモードを調べる
		texture.setAlphaPremultiplied((bufferedImage.getType() == BufferedImage.TYPE_4BYTE_ABGR_PRE));

		//	テクスチャーの元データに、変換する画像を描画する
		Graphics	g = texImage.getGraphics();

		g.setColor(new Color(0f, 0f, 0f, 0f));
		g.fillRect(0, 0, texWidth, texHeight);	//	画像は最初に透明色で塗りつぶす
		g.drawImage(bufferedImage, 0, 0, null);
		g.dispose();
		
		//	読み込んだ画像を破棄する
		bufferedImage.flush();

		//	テクスチャーの元データをバイト配列に変換する
		byte[] data = ((DataBufferByte) texImage.getRaster().getDataBuffer()).getData();
		texImage.flush();

		imageBuffer = ByteBuffer.allocateDirect(data.length);
		imageBuffer.order(ByteOrder.nativeOrder());
		imageBuffer.put(data, 0, data.length);
		imageBuffer.flip();

		return imageBuffer;
	}

	/**
	 *	テクスチャーに使われるデータ形式と同じデータ形式で、指定のサイズの BufferedImage を生成して返す
	 */
	public BufferedImage createImageData(int width, int height) {
		WritableRaster	raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 4, null);
		BufferedImage	bufferedImage = new BufferedImage(glAlphaColorModel, raster, true, new Hashtable());

		return bufferedImage;
	}
}

/*
 * Copyright (c) 2002-2008 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 test.monolith.v3;

import static org.lwjgl.opengl.GL11.glBindTexture;
import static org.lwjgl.opengl.GL11.glDeleteTextures;
import static org.lwjgl.opengl.GL11.glTexCoord2f;

public class Texture {
	private int		target;
	private int		textureID;

	private int		width;
	private int		height;

	private int		texWidth;
	private int		texHeight;
	
	private boolean	isAlphaPremultiplied;

	public Texture(int target, int textureID) {
		this.target = target;
		this.textureID = textureID;
		this.isAlphaPremultiplied = true;
	}
	
	public void point(int srcX, int srcY) {
		float	tx = 1.0f * srcX / texWidth;
		float	ty = 1.0f * srcY / texHeight;

		glTexCoord2f(tx, ty);
	}

	void setTextureHeight(int texHeight) {
		this.texHeight = texHeight;
	}

	void setTextureWidth(int texWidth) {
		this.texWidth = texWidth;
	}
	
	int getTextureWidth() {
		return texWidth;
	}

	int getTextureHeight() {
		return texHeight;
	}

	public int getWidth() {
		return width;
	}

	void setWidth(int width) {
		this.width = width;
	}

	public int getHeight() {
		return height;
	}

	void setHeight(int height) {
		this.height = height;
	}

	public boolean isAlphaPremultiplied() {
		return isAlphaPremultiplied;
	}

	void setAlphaPremultiplied(boolean isAlphaPremultiplied) {
		this.isAlphaPremultiplied = isAlphaPremultiplied;
	}

	public void dispose() {
		if (0 < textureID) {
			glDeleteTextures(textureID);
			textureID = -1;
		}
	}

	public void bind() {
		glBindTexture(target, textureID);
	}
	
}

画像ファイル

テクスチャーの生成

テクスチャーを読み込む

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

テクスチャーID

テクスチャーの大きさ

テクスチャーをポリゴンにマッピングする

テクスチャーマッピングの有効化

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

テクスチャーをマッピングする

//	表示する画像のテクスチャーをバインドする
glBindTexture(GL_TEXTURE_2D, textureID);

//	四角形を描く
glBegin(GL_QUADS);

//	色情報を設定する。アルファ値は 1f （非透過）。
glColor4f(1f, 1f, 1f, 1f);

//	右上の頂点を指定する
glTexCoord2f((280f / texureWidth), (80f / textureHeight));	//	右上の頂点に対応する、テクスチャー内の座標を指定する
glVertex3f(107, 107, 0);

//	左上の頂点を指定する
glTexCoord2f((80f / texureWidth), (80f / textureHeight));	//	左上の頂点に対応する、テクスチャー内の座標を指定する
glVertex3f(7, 107, 0);

//	左下の頂点を指定する
glTexCoord2f((80f / texureWidth), (280f / textureHeight));	//	左下の頂点に対応する、テクスチャー内の座標を指定する
glVertex3f(7, 7, 0);

//	右下の頂点を指定する
glTexCoord2f((280f / texureWidth), (280f / textureHeight));	//	右下の頂点に対応する、テクスチャー内の座標を指定する
glVertex3f(107, 7, 0);

glEnd();

テクスチャーを破棄する

//	テクスチャーを破棄する
glDeleteTextures(textureID);

クラスパスから画像を検索して読み込む

E:\>cd /d C:\eclipse\workspace\test
C:\eclipse\workspace\test> mvn eclipse:eclipse

//	クラスパスから画像を検索して読み込む
texture = new TextureLoader().loadTexture("images/texture.png", this.getClass().getClassLoader());

終わりですー