桃缶食べたい。

ソースコード

package test.blender;

import static org.lwjgl.opengl.GL11.GL_BACK;
import static org.lwjgl.opengl.GL11.GL_BLEND;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_FRONT_AND_BACK;
import static org.lwjgl.opengl.GL11.GL_LINES;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_NORMALIZE;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
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.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.opengl.GL11.glOrtho;
import static org.lwjgl.opengl.GL11.glPolygonMode;
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 java.io.IOException;

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

import test.light.LightManager;
import test.monolith.v3.TextureLoader;

public class BlenderPlayer {
	private int			width = 1000;
	private int			height = 700;
	private int			depth = 1000;
	private String		title = "Blender player";

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

	private TextureLoader	textureLoader;
	private LightManager	lightManager;
	private Model			model;

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

		try {
			//	OpenGL の初期設定

			//	オフスクリーンを初期化する際の背景色を指定する
			glClearColor(0.5f, 0.5f, 0.5f, 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);

			//	デプステストを有効にする
			glEnable(GL_DEPTH_TEST);
			
			init();

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

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

				update();

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

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

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

		textureLoader = new TextureLoader();
		
		lightManager = new LightManager();
		lightManager.initLight();
		
		//	ファイルのパス指定で画像を読み込む
		model = ObjectLoader.load("C:/blender/kuma.obj");
		model.compile(textureLoader);
	}
	
	private void terminate() {
		if (model != null) model.dispose();
	}

	private void update() throws IOException {
		lightManager.update();
		
		Display.setTitle(title + "(" + calcedFps + "fps) " + lightManager.getLabel());

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

	private void render() {
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINES);
		
		glEnable(GL_NORMALIZE);
		
		//	設定を初期化する
		glLoadIdentity();

		lightManager.light();
		
		//	行列スタックに現在の行列を退避させ、新しい行列に対してモデルビュー変換を開始する
		glPushMatrix();
		
		//	画面中央の座標を (0, 0, 0) とするよう座標系を移動する
		glTranslatef(width / 2f, height / 2f, depth / -2f);

		glRotatef(lightManager.getXAngle(), 0, 1, 0);
		glRotatef(lightManager.getYAngle(), 1, 0, 0);
		
		float sclae = 200f;
		glScalef(sclae, sclae, sclae);
		
		glColor4f(1f, 1f, 1f, 1f);

		model.render();

		//	行列スタックからもとの行列を取り出す
		glPopMatrix();
	}

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

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

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

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

package test.blender;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import test.blender.Model.DisplayList;
import test.blender.Model.Material;

public class ObjectLoader {
	private static final String DEFAULT_IMAGES_DIR = "images";

	/**
	 *	渡されたファイルパスの OBJ ファイルを読み込み、Model インスタンスとして返す
	 */
	public static Model load(String filePath) throws IOException {
		Model			model = new Model(filePath, DEFAULT_IMAGES_DIR);
		DisplayList		displayList = null;
		File			file = new File(filePath);
		BufferedReader	br = null;
		String			line;
		
		//	テキストファイルなので 1 行ずつ読み込んでパースしていく
		try {
			br = new BufferedReader(new FileReader(file));
			
			while ((line = br.readLine()) != null) {
				String[]	tokens = line.split(" ");
				
				if ((tokens.length == 4) && (tokens[0].equals("v"))) {
					//	頂点座標としてパースする
					float	x = Float.valueOf(tokens[1]);
					float	y = Float.valueOf(tokens[2]);
					float	z = Float.valueOf(tokens[3]);
				
					model.addVertex(x, y ,z);
				} else if ((tokens.length == 3) && (tokens[0].equals("vt"))) {
					//	テクスチャー座標としてパースする
					float	x = Float.valueOf(tokens[1]);
					float	y = Float.valueOf(tokens[2]);

					model.addTextureVertex(x, y);
				} else if ((tokens.length == 4) && (tokens[0].equals("vn"))) {
					//	法線としてパースする
					float	x = Float.valueOf(tokens[1]);
					float	y = Float.valueOf(tokens[2]);
					float	z = Float.valueOf(tokens[3]);
					
					model.addNormal(x, y ,z);
				} else if ((tokens.length == 4) && (tokens[0].equals("f"))) {
					//	面（頂点の集合）としてパースする
					String[]	data1 = tokens[1].split("/");
					String[]	data2 = tokens[2].split("/");
					String[]	data3 = tokens[3].split("/");

					int		vertex1Index = Integer.valueOf(data1[0]);
					int		vertex2Index = Integer.valueOf(data2[0]);;
					int		vertex3Index = Integer.valueOf(data3[0]);;

					int		textureVertex1Index = intIfExists(data1[1]);
					int		textureVertex2Index = intIfExists(data2[1]);;
					int		textureVertex3Index = intIfExists(data3[1]);;

					int		normal1Index = Integer.valueOf(data1[2]);;
					int		normal2Index = Integer.valueOf(data2[2]);;
					int		normal3Index = Integer.valueOf(data3[2]);;

					displayList.addFace(
							vertex1Index, vertex2Index, vertex3Index,
							textureVertex1Index, textureVertex2Index, textureVertex3Index,
							normal1Index, normal2Index, normal3Index);
				} else if ((tokens.length == 2) && (tokens[0].equals("mtllib"))) {
					//	mtl ファイルからマテリアルを読み込む
					loadMaterials(file.getParent(), tokens[1], model);
				} else if ((tokens.length == 2) && (tokens[0].equals("usemtl"))) {
					//	面に適用するマテリアルの指定を読み込む
					displayList.setMaterialName(tokens[1]);
				} else if ((tokens.length == 2) && (tokens[0].equals("o"))) {
					//	オブジェクトとして読み込む
					displayList = model.createDisplayList();
				}
			}
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		return model;
	}
	
	/**
	 *	渡されたファイルパスの mtl ファイルを読み込み、Model インスタンスに追加する
	 */
	private static void loadMaterials(String parentDir, String filePath, Model model) throws IOException {
		Material		material = null;
		BufferedReader	br = null;
		String			line;
		
		//	ファイルパスは、OBJ ファイルの場所を基点として扱う
		if (parentDir == null) {
			parentDir = "";
		} else if (0 < parentDir.length()) {
			parentDir = parentDir + File.separator;
		}

		//	テキストファイルなので 1 行ずつ読み込んでパースしていく
		try {
			br = new BufferedReader(new FileReader(parentDir + filePath));
			
			while ((line = br.readLine()) != null) {
				String[]	tokens = line.split(" ");

				if ((tokens.length == 2) && (tokens[0].equals("newmtl"))) {
					//	マテリアル名を読み込む
					material = model.createMaterial(tokens[1]);
				} else if ((tokens.length == 2) && (tokens[0].equals("map_Kd"))) {
					//	テクスチャーのファイル名を読み込む
					material.setTextureName(tokens[1]);
				}
			}
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	private static int intIfExists(String value) {
		try {
			return Integer.parseInt(value);
		} catch(NumberFormatException e) {
			return -1;
		}
	}

}

package test.blender;

import static org.lwjgl.opengl.GL11.GL_COMPILE;
import static org.lwjgl.opengl.GL11.GL_TRIANGLES;
import static org.lwjgl.opengl.GL11.glBegin;
import static org.lwjgl.opengl.GL11.glCallList;
import static org.lwjgl.opengl.GL11.glDeleteLists;
import static org.lwjgl.opengl.GL11.glEnd;
import static org.lwjgl.opengl.GL11.glEndList;
import static org.lwjgl.opengl.GL11.glGenLists;
import static org.lwjgl.opengl.GL11.glNewList;
import static org.lwjgl.opengl.GL11.glNormal3f;
import static org.lwjgl.opengl.GL11.glTexCoord2f;
import static org.lwjgl.opengl.GL11.glVertex3f;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.lwjgl.util.vector.Vector3f;

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

public class Model {
	private final File					objFile;
	private final File					imagesDir;
	private final List<Vector3f>		vertices = new ArrayList<Vector3f>();
	private final List<Point>			textureVertices = new ArrayList<Point>();
	private final List<Vector3f>		normals = new ArrayList<Vector3f>();
	private final Map<String, Material>	materials = new HashMap<String, Material>();
	private final List<DisplayList>		displayLists = new ArrayList<DisplayList>();
	
	public Model(String objFile, String imagesDir) {
		this.objFile = new File(objFile);
		this.imagesDir = new File(imagesDir);
	}

	/**
	 *	この Model を最適化し、必要なリソースを確保する
	 */
	public void compile(TextureLoader textureLoader) throws IOException {
		for (DisplayList displayList: displayLists) {
			displayList.compile(textureLoader);
		}
	}

	/**
	 *	この Model が持つすべてのリソースを破棄する
	 */
	public void dispose() {
		for (DisplayList displayList: displayLists) {
			displayList.dispose();
		}
	}

	/**
	 *	この Model を描画する
	 */
	public void render() {
		for (DisplayList displayList: displayLists) {
			Material	material = materials.get(displayList.materialName);

			if (material != null) {
				Texture	texture = material.texture;
				AlphaBlend.AlphaBlend.config(texture);
				texture.bind();
			}

			glCallList(displayList.objectDisplayList);
		}
	}

	public DisplayList createDisplayList() {
		DisplayList	displayList = new DisplayList();
		
		displayLists.add(displayList);
		
		return displayList;
	}

	public void addVertex(float x, float y, float z) {
		vertices.add(new Vector3f(x, y, z));
	}
	
	public Vector3f getVertex(int index) {
		return vertices.get(index - 1);
	}
	
	public void addNormal(float x, float y, float z) {
		normals.add(new Vector3f(x, y, z));
	}
	
	public Vector3f getNormal(int index) {
		return normals.get(index - 1);
	}
	
	public Point getTextureVertex(int index) {
		return textureVertices.get(index - 1);
	}
	
	public void addTextureVertex(float x, float y) {
		textureVertices.add(new Point(x, y));
	}
	
	public Material createMaterial(String name) {
		Material	material = new Material(name);

		this.materials.put(name, material);
		
		return material;
	}

	/**
	 *	モデルを構成するオブジェクトを表すクラス
	 */
	class DisplayList {
		private final List<Face>	faces = new ArrayList<Face>();
		
		private String			materialName;
		private int				objectDisplayList;

		public void setMaterialName(String materialName) {
			this.materialName = materialName;
		}

		public void compile(TextureLoader textureLoader) throws IOException {
			//	ディスプレイリストを確保し、ID を生成する
			objectDisplayList = glGenLists(1);
			
			//	ディスプレイリストへ描画処理を保存する
			glNewList(objectDisplayList, GL_COMPILE);
			{
				glBegin(GL_TRIANGLES);

				for (Face face: faces.toArray(new Face[] {})) {
					Point		texCord1 = (0 < face.textureVertex1Index)? getTextureVertex(face.textureVertex1Index): null;
					Point		texCord2 = (0 < face.textureVertex2Index)? getTextureVertex(face.textureVertex2Index): null;
					Point		texCord3 = (0 < face.textureVertex3Index)? getTextureVertex(face.textureVertex3Index): null;

					Vector3f	normal1 = getNormal(face.normal1Index);
					Vector3f	normal2 = getNormal(face.normal2Index);
					Vector3f	normal3 = getNormal(face.normal3Index);
					Vector3f	vector1 = getVertex(face.vertex1Index);
					Vector3f	vector2 = getVertex(face.vertex2Index);
					Vector3f	vector3 = getVertex(face.vertex3Index);

					glNormal3f(normal1.x, normal1.y, normal1.z);
					if (texCord1 != null) glTexCoord2f(texCord1.getX(), texCord1.getY() * -1);
					glVertex3f(vector1.x, vector1.y, vector1.z);

					glNormal3f(normal2.x, normal2.y, normal2.z);
					if (texCord2 != null) glTexCoord2f(texCord2.getX(), texCord2.getY() * -1);
					glVertex3f(vector2.x, vector2.y, vector2.z);

					glNormal3f(normal3.x, normal3.y, normal3.z);
					if (texCord3 != null) glTexCoord2f(texCord3.getX(), texCord3.getY() * -1);
					glVertex3f(vector3.x, vector3.y, vector3.z);
				}
				glEnd();
			}
			//	ディスプレイリストへの保存を終了する
			glEndList();
			
			//	テクスチャーをロードする
			Material	material = materials.get(materialName);

			if (material != null) {
				String	texturePath;
				File	textureFile = new File(material.textureName);
				
				if (textureFile.isAbsolute()) {
					texturePath = textureFile.getPath();
				} else if (imagesDir.isAbsolute()) {
					texturePath = imagesDir.getCanonicalFile().getParent() + File.separator + textureFile.getPath();
				} else {
					texturePath = objFile.getCanonicalFile().getParent() + File.separator + imagesDir.getPath() + File.separator + textureFile.getPath();
				}
				
				material.texture = textureLoader.loadTexture(texturePath);
			}
		}

		public void addFace(
				int vertex1Index, int vertex2Index, int vertex3Index,
				int textureVertex1Index, int textureVertex2Index, int textureVertex3Index,
				int normal1Index, int normal2Index, int normal3Index) {
			faces.add(new Face(
					vertex1Index, vertex2Index, vertex3Index,
					textureVertex1Index, textureVertex2Index, textureVertex3Index,
					normal1Index, normal2Index, normal3Index));
		}

		public void dispose() {
			//	テクスチャーを破棄する
			for (Material material: materials.values()) {
				material.dispose();
			}

			//	モデル描画の記録を破棄する
			glDeleteLists(objectDisplayList, 1);
		}
	}
	
	/**
	 *	オブジェクトを構成する面を表すクラス
	 *	面は三角形のみとし、各頂点がそれぞれ頂点座標、テクスチャー座標、法線のインデックスを持つ
	 */
	class Face {
		private final int		vertex1Index;
		private final int		vertex2Index;
		private final int		vertex3Index;

		private final int		textureVertex1Index;
		private final int		textureVertex2Index;
		private final int		textureVertex3Index;

		private final int		normal1Index;
		private final int		normal2Index;
		private final int		normal3Index;
		
		public Face(
				int vertex1Index, int vertex2Index, int vertex3Index,
				int textureVertex1Index, int textureVertex2Index, int textureVertex3Index,
				int normal1Index, int normal2Index, int normal3Index) {
			this.vertex1Index = vertex1Index;
			this.vertex2Index = vertex2Index;
			this.vertex3Index = vertex3Index;
			this.textureVertex1Index = textureVertex1Index;
			this.textureVertex2Index = textureVertex2Index;
			this.textureVertex3Index = textureVertex3Index;
			this.normal1Index = normal1Index;
			this.normal2Index = normal2Index;
			this.normal3Index = normal3Index;
		}
	}
	
	/**
	 *	二次元座標を表すクラス
	 */
	class Point {
		private final float	x;
		private final float	y;

		public Point(float x, float y) {
			this.x = x;
			this.y = y;
		}

		public float getX() {
			return x;
		}

		public float getY() {
			return y;
		}
	}

	/**
	 *	マテリアルを表すクラス
	 */
	class Material {
		private final String name;

		private String		textureName;
		private Texture		texture;

		public Material(String name) {
			this.name = name;
		}

		public void setTextureName(String textureName) {
			this.textureName = textureName;
		}

		public void dispose() {
			if (texture != null) {
				texture.dispose();
			}
		}
	}
}

Blender から OBJ ファイルを書き出す

モデル作成時の注意

OBJ ファイルを書き出す

各ファイルのフォーマット

obj ファイル

# mtl ファイル名
mtllib kuma.mtl

# オブジェクト名
o Sphere.005_Sphere.006

# 頂点座標 (x, y, z)
# LWJGL の glVertex3f() の引数に相当
v 0.720604 1.154850 0.090884
v 0.716250 1.155737 0.105454
v 0.704354 1.156385 0.116119
...

# テクスチャー座標 (x, y)
# LWJGL の glTexCoord2f() の引数に相当
vt 0.137180 0.625775
vt 0.133314 0.591103
vt 0.154389 0.604571
...

# 法線 (x, y, z)
# LWJGL の glNormal3f() の引数に相当
vn 0.956884 0.071054 0.281647
vn 0.667766 0.082637 0.739770
vn 0.233977 0.072171 0.969560
...

# マテリアル名。これ移行の面にはこのマテリアルが適用される。
usemtl Material.002_kuma_parts.png

# 面の頂点データ。
# 各頂点は、頂点座標のインデックス/法線のインデックス/テクスチャー座標のインデックス
f 1/1/1 13/2/1 14/3/1
f 1/1/1 14/3/1 2/4/1
f 2/4/2 14/3/2 15/5/2
...

# 以下、同じようにすべてのオブジェクトが記載されていく
o Sphere.003
v 0.959391 0.363066 -0.120141
v 0.916678 0.363066 -0.304399
v 0.857310 0.036067 -0.284332
...

mtl ファイル

# マテリアル名。
# obj ファイルの usemtl でマテリアルを指定する際に使われる。
newmtl Material.001_kuma_body.png

Ns 96.078431

# マテリアルの環境光 (r, g, b)
# LWJGL の glLight() で指定する色（第三引数）に相当
Ka 0.000000 0.000000 0.000000

# マテリアルの拡散光 (r, g, b)
# LWJGL の glLight() で指定する色（第三引数）に相当
Kd 0.640000 0.640000 0.640000

# マテリアルの鏡面光 (r, g, b)
# LWJGL の glLight() で指定する色（第三引数）に相当
Ks 0.500000 0.500000 0.500000

Ni 1.000000
d 1.000000
illum 2

# テクスチャーのファイル名。絶対パスか、obj ファイルのディレクトリからの相対パスで指定されている。
map_Kd kuma_body.png


# 以下、同じようにすべてのマテリアルが記載されていく
newmtl Material.002_kuma_parts.png
...

OBJ ファイルの読み込み

/**
 *	渡されたファイルパスの OBJ ファイルを読み込み、Model インスタンスとして返す
 */
public static Model load(String filePath) throws IOException {
	Model			model = new Model(filePath);
	File			file = new File(filePath);
	BufferedReader	br = null;
	String			line;
	
	//	テキストファイルなので 1 行ずつ読み込んでパースしていく
	try {
		br = new BufferedReader(new FileReader(file));
		
		while ((line = br.readLine()) != null) {
			String[]	tokens = line.split(" ");
			
			if ((tokens.length == 4) && (tokens[0].equals("v"))) {
				//	頂点座標としてパースする
				...
			} else if ((tokens.length == 3) && (tokens[0].equals("vt"))) {
				//	テクスチャー座標としてパースする
				...
			} else if ((tokens.length == 4) && (tokens[0].equals("vn"))) {
				//	法線としてパースする
				...
			} else if ((tokens.length == 4) && (tokens[0].equals("f"))) {
				//	面（頂点の集合）としてパースする
				...
			} else if ((tokens.length == 2) && (tokens[0].equals("mtllib"))) {
				//	mtl ファイルからマテリアルを読み込む
				...
			} else if ((tokens.length == 2) && (tokens[0].equals("usemtl"))) {
				//	面に適用するマテリアルの指定を読み込む
				...
			} else if ((tokens.length == 2) && (tokens[0].equals("o"))) {
				//	オブジェクトとして読み込む
				...
			}
		}
	} finally {
		if (br != null) {
			try {
				br.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	return model;
}

ディスプレイリスト

ディスプレイリストの保存

//	ディスプレイリストを確保し、ID を取得する
int	objectDisplayList = glGenLists(1);

//	ディスプレイリストへの保存を開始する
glNewList(objectDisplayList, GL_COMPILE);

//	保存する描画処理を書く
glBegin(GL_TRIANGLES);
glNormal3f(normal1.x, normal1.y, normal1.z);
glTexCoord2f(texCord1.getX(), texCord1.getY() * -1);
glVertex3f(vector1.x, vector1.y, vector1.z);
...
glEnd();

//	ディスプレイリストへの保存を終了する
glEndList();

ディスプレイリストの実行

//	ディスプレイリストを実行する
glCallList(objectDisplayList);

ディスプレイリストの破棄

glDeleteLists(objectDisplayList, 1);

おまけ: 先生！Blender でクマをつるつるにするクマ！

 

# Smooth 適用前
f 47//1 1//1 3//1 
f 47//1 3//1 45//1
f 4//2 2//2 48//2
...
# Smooth 適用前
f 47//1 1//2 3//3
f 47//1 3//3 45//4
f 4//5 2//6 48//7

おわり