View difference between Paste ID: 8EpNVp1e and STVqpQ8F

 import java.io.BufferedInputStream;
 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 = 2 * ReadUnsignedShort();
+
-				obj.textureBuffer = new float[num];
+				for (i = 0, k = 6; i < num; i++, k += 8) {
-				for (i = 0; i < num; i++)
+					obj.vertexBuffer[k + 0] = ReadFloat();
-					obj.textureBuffer[i] = ReadFloat();
+					obj.vertexBuffer[k + 1] = 1 - ReadFloat();
 				}
 				break;
 
 			case CHUNK_VERTLIST:
 				num = ReadUnsignedShort();
-				obj.vertexBuffer = new float[6*num];
+
-				for (i = 0, k = 0; i < num; i++, k += 6) {
+				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)
 	{
 		v[offset + 0] += a[0];
 		v[offset + 1] += a[1];
 		v[offset + 2] += a[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, num = ReadUnsignedShort(), unused = num, idx;
 
 		obj.faceCount = num;
 		obj.faceBuffer = new int[3*num];
 		obj.faceUsed = new boolean[num];
 		float[] v = new float[3];
 		float[] v1 = new float[3];
 		float[] v2 = new float[3];
 
 		for (i = 0, idx = 0; i < num; i++, idx += 3) {
 			j = ReadUnsignedShort();
 			k = ReadUnsignedShort();
 			l = ReadUnsignedShort();
 			Skip(2);
 
 			obj.faceUsed[i] = false;
 			obj.faceBuffer[idx + 0] = j;
-			j *= 6;
+
-			k *= 6;
+
-			l *= 6;
+
 			j *= 8;
 			k *= 8;
 			l *= 8;
 			VecSubstract(v1, obj.vertexBuffer, l, j);
 			VecSubstract(v2, obj.vertexBuffer, k, j);
 			CrossProduct(v, v1, v2);
 
 			VecAdd(obj.vertexBuffer, j + 3, v);
 			VecAdd(obj.vertexBuffer, k + 3, v);
-		for (i = 0, k = 3; i < obj.vertCount; i++, k += 6)
+
 		}
 
 		for (i = 0, k = 3; i < obj.vertCount; i++, k += 8)
 			VecNormalize(obj.vertexBuffer, k);
 
 		v = null;
 		v1 = null;
 		v2 = null;
 
 		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.faces = num;
 				mat.indexBuffer = new short[3*num];
 				mat.bufOffset = obj.indCount;
 				obj.indCount += 3*num;
 				k = 0;
 				for (i = 0; i < num; i++) {
 					j = ReadUnsignedShort();
 					if (!obj.faceUsed[j]) {
 						obj.faceUsed[j] = true;
 						unused--;
 					}
 					j *= 3;
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 0];
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 1];
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 2];
 				}
 				obj.faceMats.add(mat);
 				break;
 
 			case CHUNK_SMOOTHG:
 			default:
 				Skip(chunkLen);
 			}
 		}
 		Seek(end);
 
 		if (unused > 0) {
 			FaceMat mat = new FaceMat();
 			mat.faces = unused;
 			mat.indexBuffer = new short[3*unused];
 			mat.bufOffset = obj.indCount;
 			obj.indCount += 3*unused;
 			k = 0;
 			for (i = 0; i < obj.faceCount; i++)
 				if (!obj.faceUsed[i]) {
 					obj.faceUsed[i] = true;
 					j = i * 3;
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 0];
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 1];
 					mat.indexBuffer[k++] = (short) obj.faceBuffer[j + 2];
 				}
 			obj.faceMats.add(mat);
 		}
 
 		obj.faceBuffer = null;
 		obj.faceUsed = null;
 	}
 
 	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 = ChunkPercent(chunkLen) * 1000;
 				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.idParent = ReadUnsignedShort();
 				anim.parent = scene.FindAnimation(anim.idParent);
 				if (anim.parent != null) {
 					anim.parent.childNext = anim.parent.childFirst;
 					anim.parent.childFirst = anim;
 				}
 				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;
 	}
 }