View difference between Paste ID: 5fse1Uiv and 3vMjDgkf

-package com.ginkage.postcard;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 
 import android.opengl.Matrix;
 import android.os.Environment;
 
 public class Load3DS {
 	private final int CHUNK_MAIN     = 0x4D4D;
 	private final int CHUNK_OBJMESH  = 0x3D3D;
 	private final int CHUNK_OBJBLOCK = 0x4000;
 	private final int CHUNK_TRIMESH  = 0x4100;
 	private final int CHUNK_VERTLIST = 0x4110;
 	private final int CHUNK_FACELIST = 0x4120;
 	private final int CHUNK_FACEMAT  = 0x4130;
 	private final int CHUNK_MAPLIST  = 0x4140;
 	private final int CHUNK_SMOOTHG  = 0x4150;
 	private final int CHUNK_TRMATRIX = 0x4160;
 	private final int CHUNK_LIGHT    = 0x4600;
 	private final int CHUNK_SPOTL    = 0x4610;
 	private final int CHUNK_ONOFF    = 0x4620;
 	private final int CHUNK_CAMERA   = 0x4700;
 	private final int CHUNK_RGBC     = 0x0010;
 	private final int CHUNK_RGB24    = 0x0011;
 	private final int CHUNK_SHORT    = 0x0030;
 	private final int CHUNK_BACKCOL  = 0x1200;
 	private final int CHUNK_AMB      = 0x2100;
 	private final int CHUNK_MATERIAL = 0xAFFF;
 	private final int CHUNK_MATNAME  = 0xA000;
 	private final int CHUNK_AMBIENT  = 0xA010;
 	private final int CHUNK_DIFFUSE  = 0xA020;
 	private final int CHUNK_SPECULAR = 0xA030;
 	private final int CHUNK_SHININES = 0xA040;
 	private final int CHUNK_SHINSTRN = 0xA041;
 	private final int CHUNK_TRANSP   = 0xA050;
 	private final int CHUNK_SELFILL  = 0xA084;
 	private final int CHUNK_MTLTYPE  = 0xA100;
 	private final int CHUNK_TEXTURE  = 0xA200;
 	private final int CHUNK_REFLMAP  = 0xA220;
 	private final int CHUNK_BUMPMAP  = 0xA230;
 	private final int CHUNK_MAPFILE  = 0xA300;
 	private final int CHUNK_MAPPARAM = 0xA351;
 	private final int CHUNK_KEYFRAMER = 0xB000;
 	private final int CHUNK_TRACKINFO = 0xB002;
 	private final int CHUNK_SPOTINFO  = 0xB007;
 	private final int CHUNK_FRAMES    = 0xB008;
 	private final int CHUNK_OBJNAME   = 0xB010;
 	private final int CHUNK_PIVOT     = 0xB013;
 	private final int CHUNK_TRACKPOS  = 0xB020;
 	private final int CHUNK_TRACKROT  = 0xB021;
 	private final int CHUNK_TRACKSCL  = 0xB022;
 	private final int CHUNK_HIERARCHY = 0xB030;
 
 	private BufferedInputStream file;
 	private byte[] bytes = new byte[8];
 	private long filePos;
 
 	public Scene3D Load(String fileName)
 	{
 		file = null;
 		Scene3D scene = null;
 		File dir = new File(Environment.getExternalStorageDirectory().getAbsolutePath());
 		File fil = new File(dir.getAbsolutePath() + File.separator + fileName);
 		if (!fil.exists()) return scene;
 
 		try {
 			filePos = 0;
 			file = new BufferedInputStream(new FileInputStream(fil));
 			scene = ProcessFile(fil.length());
 		} catch (FileNotFoundException e) {
 			e.printStackTrace();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 
 		try {
 			if (file != null)
 				file.close();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 
 		return scene;
 	}
 
 	private void Skip(long count) throws IOException
 	{
 		file.skip(count);
 		filePos += count;
 	}
 
 	private void Seek(long end) throws IOException
 	{
 		if (filePos < end) {
 			Skip(end - filePos);
 			filePos = end;
 		}
 	}
 
 	private byte ReadByte() throws IOException
 	{
 		file.read(bytes, 0, 1);
 		filePos++;
 		return bytes[0];
 	}
 
 	private int ReadUnsignedByte() throws IOException
 	{
 		file.read(bytes, 0, 1);
 		filePos++;
 		return (bytes[0]&0xff);
 	}
 
 	private int ReadUnsignedShort() throws IOException
 	{
 		file.read(bytes, 0, 2);
 		filePos += 2;
 		return ((bytes[1]&0xff) << 8 | (bytes[0]&0xff));
 	}
 
 	private int ReadInt() throws IOException
 	{
 		file.read(bytes, 0, 4);
 		filePos += 4;
 		return (bytes[3]) << 24 | (bytes[2]&0xff) << 16 | (bytes[1]&0xff) <<  8 | (bytes[0]&0xff);
 	}
 
 	private float ReadFloat() throws IOException
 	{
 		return Float.intBitsToFloat(ReadInt());
 	}
 
 	private Scene3D ProcessFile(long fileLen) throws IOException
 	{
 		Scene3D scene = null;
 
 		while (filePos < fileLen) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_MAIN:
 				if (scene == null)
 					scene = ChunkMain(chunkLen);
 				else
 					Skip(chunkLen);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 
 		return scene;
 	}
 
 	private Scene3D ChunkMain(int len) throws IOException
 	{
 		Scene3D scene = new Scene3D();
 		scene.materials = new ArrayList<Material3D>();
 		scene.objects = new ArrayList<Object3D>();
 		scene.lights = new ArrayList<Light3D>();
 		scene.animations = new ArrayList<Animation>();
 
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_OBJMESH:
 				Chunk3DEditor(scene, chunkLen);
 				break;
 
 			case CHUNK_KEYFRAMER:
 				ChunkKeyframer(scene, chunkLen);
 				break;
 
 			case CHUNK_BACKCOL:
 				scene.background = new float[4];
 				ChunkColor(chunkLen, scene.background);
 				break;
 
 			case CHUNK_AMB:
 				scene.ambient = new float[4];
 				ChunkColor(chunkLen, scene.ambient);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		scene.Compute(0);
 
 		return scene;
 	}
 
 	private void Chunk3DEditor(Scene3D scene, int len) throws IOException
 	{
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_OBJBLOCK:
 				ChunkObject(scene, chunkLen);
 				break;
 
 			case CHUNK_MATERIAL:
 				Material3D mat = ChunkMaterial(scene, chunkLen);
 				if (mat != null)
 					scene.materials.add(mat);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 	}
 
 	private void ChunkObject(Scene3D scene, int len) throws IOException
 	{
 		long end = filePos + len;
 
 		if (len == 0) return;
 		String name = ChunkName(0);
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_TRIMESH:
 				Object3D obj = ChunkTrimesh(chunkLen, name, scene);
 				if (obj != null)
 					scene.objects.add(obj);
 				break;
 
 			case CHUNK_LIGHT:
 				Light3D light = ChunkLight(chunkLen, name);
 				if (light != null)
 					scene.lights.add(light);
 				break;
 
 			case CHUNK_CAMERA:
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 	}
 
 	private Object3D ChunkTrimesh(int len, String name, Scene3D scene) throws IOException
 	{
 		long end = filePos + len;
 
 		Object3D obj = new Object3D();
 		obj.name = name;
 		obj.faceMats = new ArrayList<FaceMat>();
 		obj.indCount = 0;
 
 		int i, k, num;
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_FACELIST:
 				ChunkFaceList(chunkLen, obj, scene);
 				break;
 
 			case CHUNK_MAPLIST:
 				num = ReadUnsignedShort();
 				for (i = 0, k = 6; i < num; i++, k += 8) {
 					obj.vertexBuffer[k + 0] = ReadFloat();
 					obj.vertexBuffer[k + 1] = 1 - ReadFloat();
 				}
 				break;
 
 			case CHUNK_VERTLIST:
 				num = ReadUnsignedShort();
 				obj.vertCount = num;
 				obj.vertexBuffer = new float[8*num];
 				for (i = 0, k = 0; i < num; i++, k += 8) {
 					ChunkVector(obj.vertexBuffer, k);
 					obj.vertexBuffer[k + 3] = 0;
 					obj.vertexBuffer[k + 4] = 0;
 					obj.vertexBuffer[k + 5] = 0;
 					obj.vertexBuffer[k + 6] = 0;
 					obj.vertexBuffer[k + 7] = 0;
 				}
 				break;
 
 			case CHUNK_TRMATRIX:
 				float[] localCoord = new float[16];
 				ChunkVector(localCoord, 4*0);
 				ChunkVector(localCoord, 4*2);
 				ChunkVector(localCoord, 4*1);
 				ChunkVector(localCoord, 4*3);
 				localCoord[3] = localCoord[7] = localCoord[11] = 0;
 				localCoord[15] = 1;
 
 				obj.trMatrix = new float[16];
 				Matrix.invertM(obj.trMatrix, 0, localCoord, 0);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return obj;
 	}
 
 	private static void CrossProduct(float[] res, float[] v1, float[] v2)
 	{
 		res[0] = v1[1]*v2[2] - v1[2]*v2[1];
 		res[1] = v1[2]*v2[0] - v1[0]*v2[2];
 		res[2] = v1[0]*v2[1] - v1[1]*v2[0];
 	}
 
 	private static float DotSquare(float[] v, int offset)
 	{
 		return v[offset + 0]*v[offset + 0] + v[offset + 1]*v[offset + 1] + v[offset + 2]*v[offset + 2];
 	}
 
 	private static void VecSubstract(float[] res, float[] v, int offset1, int offset2)
 	{
 		res[0] = v[offset1 + 0] - v[offset2 + 0];
 		res[1] = v[offset1 + 1] - v[offset2 + 1];
 		res[2] = v[offset1 + 2] - v[offset2 + 2];
 	}
 
 	private static void VecAdd(float[] v, int offset, float[] a, int off)
 	{
 		v[offset + 0] += a[off + 0];
 		v[offset + 1] += a[off + 1];
 		v[offset + 2] += a[off + 2];
 	}
 
 	private void VecNormalize(float[] v, int offset)
 	{
 		double nlen = 1 / Math.sqrt(DotSquare(v, offset));
 		v[offset + 0] *= nlen;
 		v[offset + 1] *= nlen;
 		v[offset + 2] *= nlen;
 	}
 
 	private void ChunkFaceList(int len, Object3D obj, Scene3D scene) throws IOException
 	{
 		long end = filePos + len;
 
 		int i, j, k, l, m, t, num = ReadUnsignedShort(), unused = num, idx;
 
 		int faceCount = num;
 		int[] faceBuffer = new int[3*faceCount];
 		boolean[] faceUsed = new boolean[faceCount];
 		float[] v = new float[3];
 		float[] v1 = new float[3];
 		float[] v2 = new float[3];
 
 		float[] vgNorm = new float[3*3*faceCount]; // per-vertex normal for each face
 		int[] vertGroup = new int[3*faceCount]; // per-vertex group for each face
 		boolean[] vgUsed = new boolean[3*faceCount]; // per-vertex "group used" bit for each face
 		int[] vgNum = new int[obj.vertCount + 1]; // per-vertex face count, and then offset
 		int[] faceGroup = new int[faceCount]; // per-face smoothing group
 
 		int[] vgUniqs = new int[obj.vertCount + 1]; // per-vertex unique groups count
 		int[] vertUGroup = new int[3*faceCount]; // per-vertex unique groups list for each face
 
 		for (i = 0; i <= obj.vertCount; i++)
 			vgNum[i] = vgUniqs[i] = 0;
 
 		for (i = 0, idx = 0; i < faceCount; i++, idx += 3) {
 			j = ReadUnsignedShort();
 			k = ReadUnsignedShort();
 			l = ReadUnsignedShort();
 			Skip(2);
 
 			faceUsed[i] = false;
 			faceBuffer[idx + 0] = j;
 			faceBuffer[idx + 2] = k;
 			faceBuffer[idx + 1] = l;
 
 			// initialize smoothing groups data
 			faceGroup[i] = 0;
 
 			for (t = 0; t < 9; t++)
 				vgNorm[i * 9 + t] = 0;
 
 			for (t = 0; t < 3; t++) {
 				vertGroup[idx + t] = 0;
 				vertUGroup[idx + t] = 0;
 				vgUsed[idx + t] = false;
 			}
 
 			vgNum[j]++;
 			vgNum[k]++;
 			vgNum[l]++;
 		}
 
 		int a, sum = 0;
 		for (i = 0; i < obj.vertCount; i++) {
 			a = vgNum[i];
 			vgNum[i] = sum;
 			sum += a;
 		}
 		vgNum[obj.vertCount] = sum; // now we can store all the faces and their normals and groups per-vertex
 
 		for (i = 0, idx = 0; i < faceCount; i++, idx += 3) {
 			j = faceBuffer[idx + 0];
 			k = faceBuffer[idx + 2];
 			l = faceBuffer[idx + 1];
 
 			VecSubstract(v1, obj.vertexBuffer, l*8, j*8);
 			VecSubstract(v2, obj.vertexBuffer, k*8, j*8);
 			CrossProduct(v, v1, v2);
 
 			VecAdd(vgNorm, vgNum[j]*3, v, 0);
 			VecAdd(vgNorm, vgNum[k]*3, v, 0);
 			VecAdd(vgNorm, vgNum[l]*3, v, 0);
 
 			vgNum[j]++;
 			vgNum[k]++;
 			vgNum[l]++;
 		}
 
 		for (i = obj.vertCount - 1; i > 0; i--) // offsets were shifted, so shift them back
 			vgNum[i] = vgNum[i - 1];
 		vgNum[0] = 0;
 
 		boolean gotSmoothGroups = false;
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_FACEMAT:
 				FaceMat mat = new FaceMat();
 				String name = ChunkName(0);
 				mat.material = scene.FindMaterial(name);
 				num = ReadUnsignedShort();
 				mat.indCount = num;
 				mat.indexBuffer = new int[3*num];
 				mat.bufOffset = obj.indCount;
 				obj.indCount += 3*num;
 				k = 0;
 				for (i = 0; i < num; i++) {
 					j = ReadUnsignedShort();
 					if (!faceUsed[j]) {
 						faceUsed[j] = true;
 						unused--;
 					}
 					j *= 3;
 					for (t = 0; t < 3; t++)
 						mat.indexBuffer[k++] = j;
 				}
 				obj.faceMats.add(mat);
 				break;
 
 			case CHUNK_SMOOTHG:
 				for (i = 0, idx = 0; i < faceCount; i++, idx += 3) {
 					faceGroup[i] = ReadInt();
 
 					for (t = 0; t < 3; t++) {
 						j = faceBuffer[idx + t];
 						vertGroup[vgNum[j]] = faceGroup[i];
 						vgNum[j]++;
 					}
 				}
 				for (i = obj.vertCount - 1; i > 0; i--)
 					vgNum[i] = vgNum[i - 1];
 				vgNum[0] = 0;
 				gotSmoothGroups = true;
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		int newVertCount = 0, g;
 
 		if (gotSmoothGroups) {
 			for (i = 0; i < obj.vertCount; i++) {
 				for (m = vgNum[i]; m < vgNum[i + 1]; m++) { // for every normal and face of this vertex
 					if (!vgUsed[m]) {
 						// vertGroup[m] is a new group...
 						vertUGroup[vgNum[i] + vgUniqs[i]] = vertGroup[m];
 						vgUniqs[i]++;
 						newVertCount++;
 					}
 
 					for (t = m; t < vgNum[i + 1]; t++) // mark all equal groups (including this one) as duplicates
 						if (vertGroup[t] == vertGroup[m])
 							vgUsed[t] = true;
 				}
 			}
 
 			if (newVertCount == obj.vertCount)
 				gotSmoothGroups = false;
 		}
 
 		if (gotSmoothGroups) {
 			// reindex all vertices, build new normals
 			int newIndex = 0;
 			int[] vertIndex = new int[faceCount*3]; // new vertex indices
 			float[] newVertexBuffer = new float[newVertCount*8];
 
 			for (i = 0, idx = 0; i < faceCount; i++, idx += 3)
 				for (t = 0; t < 3; t++)
 					vertIndex[idx + t] = 0;
 
 			idx = 3;
 			for (i = 0; i < obj.vertCount; i++) {
 				for (t = 0; t < vgUniqs[i]; t++) { // for every unique normal and face of this vertex
 					for (m = 0; m < 8; m++)
 						newVertexBuffer[newIndex*8 + m] = obj.vertexBuffer[i*8 + m]; // duplicate all vertex data (including zero normals)
 
 					g = vertUGroup[vgNum[i] + t]; // unique group mask for this vertex
 					for (m = vgNum[i]; m < vgNum[i + 1]; m++) // for every NON-unique normal and face of this vertex
 						if ((vertGroup[m] & g) != 0 || vertGroup[m] == g) // also works for zero group
 							VecAdd(newVertexBuffer, idx, vgNorm, m*3); // add normal to vertex
 
 					vertIndex[vgNum[i] + t] = newIndex;
 					newIndex++;
 					idx += 8;
 				}
 			}
 
 			int fg, vi;
 			for (i = 0, idx = 0; i < faceCount; i++, idx += 3) {
 				fg = faceGroup[i];
 				for (m = 0; m < 3; m++) {
 					vi = faceBuffer[idx + m]; // face vertex
 					for (t = 0; t < vgUniqs[vi]; t++) // for every unique group of this vertex
 						if (fg == vertUGroup[vgNum[vi] + t]) { // found the right one
 							faceBuffer[idx + m] = vertIndex[vgNum[vi] + t];
 							break;
 						}
 				}
 			}
 
 			obj.vertCount = newVertCount;
 			obj.vertexBuffer = newVertexBuffer;
 		}
 		else // nothing changed, no need to recalculate anything
 			for (i = 0, idx = 3; i < obj.vertCount; i++, idx += 8) // just copy all the normals
 				for (m = vgNum[i]; m < vgNum[i + 1]; m++) // for every NON-unique normal and face of this vertex
 					VecAdd(obj.vertexBuffer, idx, vgNorm, m*3); // add normal to vertex
 
 		for (i = 0, k = 3; i < obj.vertCount; i++, k += 8)
 			VecNormalize(obj.vertexBuffer, k);
 
 		for (m = 0; m < obj.faceMats.size(); m++) {
 			FaceMat mat = obj.faceMats.get(m);
 			k = 0;
 			for (i = 0; i < mat.indCount; i++)
 				for (t = 0; t < 3; t++) {
 					j = mat.indexBuffer[k];
 					mat.indexBuffer[k++] = faceBuffer[j + t];
 				}
 		}
 
 		if (unused > 0) {
 			FaceMat mat = new FaceMat();
 			mat.indexBuffer = new int[3*unused];
 			mat.bufOffset = obj.indCount;
 			obj.indCount += 3*unused;
 			k = 0;
 			for (i = 0; i < faceCount; i++)
 				if (!faceUsed[i]) {
 					faceUsed[i] = true;
 					j = i * 3;
 					for (t = 0; t < 3; t++)
 						mat.indexBuffer[k++] = faceBuffer[j + t];
 				}
 			obj.faceMats.add(mat);
 		}
 	}
 
 	private Light3D ChunkLight(int len, String name) throws IOException
 	{
 		long end = filePos + len;
 
 		Light3D light = new Light3D();
 		light.name = name;
 		light.pos = new float[3];
 		ChunkVector(light.pos, 0);
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_RGBC:
 				light.color = new float[4];
 				ChunkRGBC(light.color);
 				break;
 
 			case CHUNK_RGB24:
 				light.color = new float[4];
 				ChunkRGB24(light.color);
 				break;
 
 			case CHUNK_SPOTL:
 				light.dir = new float[4];
 				ChunkVector(light.dir, 0);
 				light.theta = (float) (ReadFloat() * Math.PI / 180.0f);
 				light.phi = (float) (ReadFloat() * Math.PI / 180.0f);
 				break;
 
 			case CHUNK_ONOFF:
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return light;
 	}
 
 	private Material3D ChunkMaterial(Scene3D scene, int len) throws IOException
 	{
 		long end = filePos + len;
 
 		Material3D mat = new Material3D();
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_TEXTURE:
 				mat.texture = ChunkMap(chunkLen);
 				break;
 
 			case CHUNK_BUMPMAP:
 			case CHUNK_REFLMAP:
 				ChunkMap(chunkLen);
 				break;
 
 			case CHUNK_AMBIENT:
 				mat.ambient = new float[4];
 				ChunkColor(chunkLen, mat.ambient);
 				break;
 
 			case CHUNK_DIFFUSE:
 				mat.diffuse = new float[4];
 				ChunkColor(chunkLen, mat.diffuse);
 				break;
 
 			case CHUNK_SPECULAR:
 				mat.specular = new float[4];
 				ChunkColor(chunkLen, mat.specular);
 				break;
 
 			case CHUNK_MATNAME:
 				mat.name = ChunkName(chunkLen);
 				break;
 
 			case CHUNK_MTLTYPE:
 				mat.type = ReadUnsignedShort();
 				break;
 
 			case CHUNK_SHININES:
 				mat.shininess = 100 - ChunkPercent(chunkLen);
 				break;
 
 			case CHUNK_SHINSTRN:
 				mat.shinStren = ChunkPercent(chunkLen);
 				break;
 
 			case CHUNK_TRANSP:
 				mat.transparency = ChunkPercent(chunkLen);
 				break;
 
 			case CHUNK_SELFILL:
 				mat.selfIllum = ChunkPercent(chunkLen);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return mat;
 	}
 
 	private String ChunkMap(int len) throws IOException
 	{
 		long end = filePos + len;
 
 		String name = null;
 
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_MAPFILE:
 				name = ChunkName(chunkLen);
 				break;
 
 			case CHUNK_MAPPARAM:
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return name;
 	}
 
 	private void ChunkKeyframer(Scene3D scene, int len) throws IOException
 	{
 		int fstart = 0, fend = 100;
 
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_FRAMES:
 				fstart = ReadInt();
 				fend = ReadInt();
 				break;
 
 			case CHUNK_TRACKINFO:
 				Animation anim = ChunkMeshTrack(chunkLen, scene);
 				if (anim != null)
 					scene.animations.add(anim);
 				break;
 
 			case CHUNK_SPOTINFO:
 			default:
 				Skip(chunkLen);
 			}
 		}
 
 		if (fstart < fend)
 			for (int i = 0; i < scene.animations.size(); i++) {
 				Animation anim = scene.animations.get(i);
 				if (anim.position != null)
 					for (int j = 0; j < anim.position.length; j++)
 						anim.position[j].time = (anim.position[j].time - fstart) / (fend - fstart);
 				if (anim.rotation != null)
 					for (int j = 0; j < anim.rotation.length; j++)
 						anim.rotation[j].time = (anim.rotation[j].time - fstart) / (fend - fstart);
 				if (anim.scaling != null)
 					for (int j = 0; j < anim.scaling.length; j++)
 						anim.scaling[j].time = (anim.scaling[j].time - fstart) / (fend - fstart);
 			}
 
 		Seek(end);
 	}
 
 	private Animation ChunkMeshTrack(int len, Scene3D scene) throws IOException
 	{
 		Animation anim = new Animation();
 		int num, i, j, k;
 
 		anim.result = new float[16];
 		Matrix.setIdentityM(anim.result, 0);
 
 		anim.world = new float[16];
 		Matrix.setIdentityM(anim.world, 0);
 
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_HIERARCHY:
 				anim.id = ReadUnsignedShort();
 				break;
 
 			case CHUNK_OBJNAME:
 				String name = ChunkName(0);
 				anim.light = scene.FindLight(name);
 				anim.object = scene.FindObject(name);
 				Skip(4);
 				anim.parent = scene.FindAnimation(ReadUnsignedShort());
 				break;
 
 			case CHUNK_PIVOT:
 				anim.pivot = new float[3];
 				ChunkVector(anim.pivot, 0);
 				break;
 
 			case CHUNK_TRACKPOS:
 				Skip(10);
 				num = ReadInt();
 				anim.position = new AnimKey[num];
 				for (i = 0; i < num; i++) {
 					anim.position[i] = new AnimKey();
 					anim.position[i].time = ReadInt();
 					k = ReadUnsignedShort();
 					for (j = 0; j < 5; j++)
 						if ((k & (1 << j)) != 0)
 							Skip(4);
 					anim.position[i].data = new float[3];
 					ChunkVector(anim.position[i].data, 0);
 				}
 				break;
 
 			case CHUNK_TRACKROT:
 				Skip(10);
 				num = ReadInt();
 				anim.rotation = new AnimKey[num];
 				for (i = 0; i < num; i++) {
 					anim.rotation[i] = new AnimKey();
 					anim.rotation[i].time = ReadInt();
 					k = ReadUnsignedShort();
 					for (j = 0; j < 5; j++)
 						if ((k & (1 << j)) != 0)
 							Skip(4);
 					anim.rotation[i].data = new float[4];
 					anim.rotation[i].data[3] = ReadFloat();
 					ChunkVector(anim.rotation[i].data, 0);
 				}
 				break;
 
 			case CHUNK_TRACKSCL:
 				Skip(10);
 				num = ReadInt();
 				anim.scaling = new AnimKey[num];
 				for (i = 0; i < num; i++) {
 					anim.scaling[i] = new AnimKey();
 					anim.scaling[i].time = ReadInt();
 					k = ReadUnsignedShort();
 					for (j = 0; j < 5; j++)
 						if ((k & (1 << j)) != 0)
 							Skip(4);
 					anim.scaling[i].data = new float[3];
 					ChunkVector(anim.scaling[i].data, 0);
 				}
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return anim;
 	}
 
 	private void ChunkColor(int len, float[] color) throws IOException
 	{
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_RGBC:
 				ChunkRGBC(color);
 				break;
 
 			case CHUNK_RGB24:
 				ChunkRGB24(color);
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 	}
 
 	private float ChunkPercent(int len) throws IOException
 	{
 		float v = 0;
 
 		long end = filePos + len;
 		while (filePos < end) {
 			int chunkID = ReadUnsignedShort();
 			int chunkLen = ReadInt() - 6;
 
 			switch (chunkID) {
 			case CHUNK_SHORT:
 				v = ReadUnsignedShort() / 100.0f;
 				break;
 
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		return v;
 	}
 
 	private String ChunkName(int len) throws IOException
 	{
 		long end = filePos + len;
 		int slen = 0;
 		byte[] buffer = new byte[128];
 		byte c;
 
 		do {
 			c = ReadByte();
 			if (c != 0)
 				buffer[slen++] = c;
 		} while (c != 0);
 
 		if (len != 0)
 			Seek(end);
 
 		String name = new String(buffer, 0, slen);
 
 		return name;
 	}
 
 	private void ChunkVector(float[] vec, int offset) throws IOException
 	{
 		vec[offset + 0] = ReadFloat();
 		vec[offset + 2] = ReadFloat();
 		vec[offset + 1] = ReadFloat();
 	}
 
 	private void ChunkRGBC(float[] c) throws IOException
 	{
 		c[0] = ReadFloat();
 		c[1] = ReadFloat();
 		c[2] = ReadFloat();
 		c[3] = 1;
 	}
 
 	private void ChunkRGB24(float[] c) throws IOException
 	{
 		c[0] = ReadUnsignedByte() / 255.0f;
 		c[1] = ReadUnsignedByte() / 255.0f;
 		c[2] = ReadUnsignedByte() / 255.0f;
 		c[3] = 1;
 	}
 }