Android example source code file (Object3D.java)

This example Android source code file (Object3D.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

bad, bytebuffer, datainputstream, group, hashmap, intbuffer, io, ioexception, iterator, map, material, nio, object3d, runtimeexception, texture, util

The Object3D.java Android example source code

/*
 * 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);
        }
    }
}