| /* | |
| * Copyright (C) 2006 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| package android.opengl; | |
| import java.io.BufferedReader; | |
| import java.io.DataInputStream; | |
| import java.io.InputStream; | |
| import java.io.InputStreamReader; | |
| import java.io.IOException; | |
| import java.nio.ByteBuffer; | |
| import java.nio.ByteOrder; | |
| import java.nio.IntBuffer; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import javax.microedition.khronos.opengles.*; | |
| /** | |
| * {@hide} | |
| */ | |
| public abstract class Object3D { | |
| private boolean mHasTexcoords = false; | |
| private float mBoundsMinX = Float.MAX_VALUE; | |
| private float mBoundsMaxX = Float.MIN_VALUE; | |
| private float mBoundsMinY = Float.MAX_VALUE; | |
| private float mBoundsMaxY = Float.MIN_VALUE; | |
| private float mBoundsMinZ = Float.MAX_VALUE; | |
| private float mBoundsMaxZ = Float.MIN_VALUE; | |
| private IntBuffer mVertexBuffer; | |
| private IntBuffer mNormalBuffer; | |
| private IntBuffer mTexcoordBuffer; | |
| // All groups, by name | |
| private Map<String, Group> mGroups; | |
| // All materials, by name | |
| private Map<String, Material> mMaterials; | |
| // All texture maps, by name | |
| private Map<String, Texture> mTextures; | |
| public Object3D() { | |
| reset(); | |
| } | |
| /** | |
| * Override this method with an implementation that contructs | |
| * and InputStream from the given filename. For example, if the | |
| * source files are to be retrieved using an AssetManager, | |
| * the implementation would use AssetManager.load() to | |
| * get the input stream. | |
| */ | |
| public abstract InputStream readFile(String filename) throws IOException; | |
| private void reset() { | |
| mVertexBuffer = mNormalBuffer = mTexcoordBuffer = null; | |
| mGroups = new HashMap<String,Group>(); | |
| mMaterials = new HashMap<String,Material>(); | |
| mTextures = new HashMap<String,Texture>(); | |
| } | |
| public Material getMaterial(String name) { | |
| Material mat = mMaterials.get(name); | |
| return mat; | |
| } | |
| public Texture getTexture(String name) { | |
| return mTextures.get(name); | |
| } | |
| public IntBuffer getVertexBuffer() { | |
| return mVertexBuffer; | |
| } | |
| public IntBuffer getNormalBuffer() { | |
| return mNormalBuffer; | |
| } | |
| public IntBuffer getTexcoordBuffer() { | |
| return mTexcoordBuffer; | |
| } | |
| public int getNumTriangles() { | |
| int numTriangles = 0; | |
| Iterator<Group> iter = mGroups.values().iterator(); | |
| while (iter.hasNext()) { | |
| numTriangles += iter.next().getNumTriangles(); | |
| } | |
| return numTriangles; | |
| } | |
| public boolean hasTexcoords() { | |
| return mHasTexcoords; | |
| } | |
| public float getBoundsMinX() { | |
| return mBoundsMinX; | |
| } | |
| public float getBoundsMaxX() { | |
| return mBoundsMaxX; | |
| } | |
| public float getBoundsMinY() { | |
| return mBoundsMinY; | |
| } | |
| public float getBoundsMaxY() { | |
| return mBoundsMaxY; | |
| } | |
| public float getBoundsMinZ() { | |
| return mBoundsMinZ; | |
| } | |
| public float getBoundsMaxZ() { | |
| return mBoundsMaxZ; | |
| } | |
| public void loadTexture(String name) throws IOException { | |
| InputStream is = readFile(name + ".raw"); | |
| Texture texture = new Texture(is); | |
| mTextures.put(name, texture); | |
| } | |
| private static void verifyByte(DataInputStream dis, int b) | |
| throws IOException { | |
| int x = dis.read() & 0xff; | |
| if (x != b) { | |
| throw new RuntimeException("Bad byte: " + | |
| x + | |
| " (expected " + b + ")"); | |
| } | |
| } | |
| public void load(String filename) throws IOException { | |
| reset(); | |
| DataInputStream dis = new DataInputStream(readFile(filename)); | |
| verifyByte(dis, 'g' + 128); | |
| verifyByte(dis, 'l'); | |
| verifyByte(dis, 'e'); | |
| verifyByte(dis, 's'); | |
| int numTuples = dis.readInt(); | |
| this.mBoundsMinX = dis.readFloat(); | |
| this.mBoundsMaxX = dis.readFloat(); | |
| this.mBoundsMinY = dis.readFloat(); | |
| this.mBoundsMaxY = dis.readFloat(); | |
| this.mBoundsMinZ = dis.readFloat(); | |
| this.mBoundsMaxZ = dis.readFloat(); | |
| this.mHasTexcoords = dis.readInt() == 1; | |
| int intsPerTuple = mHasTexcoords ? 8 : 6; | |
| int numInts = numTuples*intsPerTuple; | |
| int len = 4*numTuples*(mHasTexcoords ? 8 : 6); | |
| byte[] tmp = new byte[len]; | |
| int tidx = 0; | |
| while (tidx < len) { | |
| tidx += dis.read(tmp, tidx, len - tidx); | |
| } | |
| if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) { | |
| for (int i = 0; i < len; i += 4) { | |
| byte tmp0 = tmp[i]; | |
| byte tmp1 = tmp[i + 1]; | |
| byte tmp2 = tmp[i + 2]; | |
| byte tmp3 = tmp[i + 3]; | |
| tmp[i] = tmp3; | |
| tmp[i + 1] = tmp2; | |
| tmp[i + 2] = tmp1; | |
| tmp[i + 3] = tmp0; | |
| } | |
| } | |
| ByteBuffer allbb = ByteBuffer.allocateDirect(len); | |
| allbb.order(ByteOrder.nativeOrder()); | |
| allbb.put(tmp); | |
| allbb.position(0); | |
| allbb.limit(4*3*numTuples); | |
| ByteBuffer vbb = allbb.slice(); | |
| this.mVertexBuffer = vbb.asIntBuffer(); | |
| mVertexBuffer.position(0); | |
| if (mHasTexcoords) { | |
| allbb.position(allbb.limit()); | |
| allbb.limit(allbb.position() + 4*2*numTuples); | |
| ByteBuffer tbb = allbb.slice(); | |
| this.mTexcoordBuffer = tbb.asIntBuffer(); | |
| mTexcoordBuffer.position(0); | |
| } | |
| allbb.position(allbb.limit()); | |
| allbb.limit(allbb.position() + 4*3*numTuples); | |
| ByteBuffer nbb = allbb.slice(); | |
| this.mNormalBuffer = nbb.asIntBuffer(); | |
| mNormalBuffer.position(0); | |
| int numMaterials = dis.readInt(); | |
| for (int i = 0; i < numMaterials; i++) { | |
| Material mat = new Material(this); | |
| mat.load(dis); | |
| mMaterials.put(mat.getName(), mat); | |
| } | |
| int numGroups = dis.readInt(); | |
| for (int i = 0; i < numGroups; i++) { | |
| Group g = new Group(this); | |
| g.load(dis); | |
| mGroups.put(g.getName(), g); | |
| } | |
| } | |
| public void draw(GL10 gl) { | |
| Iterator<Group> iter = mGroups.values().iterator(); | |
| while (iter.hasNext()) { | |
| iter.next().draw(gl); | |
| } | |
| } | |
| } | |