Android example source code file (Shape.java)

This example Android source code file (Shape.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

bytebuffer, degrees_to_radians, int_bytes, intbuffer, io, nio, pi_over_two, shape, short_bytes, shortbuffer, two_pi

The Shape.java Android example source code

/*
 * Copyright (C) 2007 Google Inc.
 *
 * 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 com.android.globaltime;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

import javax.microedition.khronos.opengles.GL10;

/**
 * An abstract superclass for various three-dimensional objects to be drawn
 * using OpenGL ES.  Each subclass is responsible for setting up NIO buffers
 * containing vertices, texture coordinates, colors, normals, and indices.
 * The {@link #draw(GL10)} method draws the object to the given OpenGL context.
 */
public abstract class Shape {

    public static final int INT_BYTES = 4;
    public static final int SHORT_BYTES = 2;

    public static final float DEGREES_TO_RADIANS = (float) Math.PI / 180.0f;
    public static final float PI = (float) Math.PI;
    public static final float TWO_PI = (float) (2.0 * Math.PI);
    public static final float PI_OVER_TWO = (float) (Math.PI / 2.0);

    protected int mPrimitive;
    protected int mIndexDatatype;

    protected boolean mEmitTextureCoordinates;
    protected boolean mEmitNormals;
    protected boolean mEmitColors;

    protected IntBuffer mVertexBuffer;
    protected IntBuffer mTexcoordBuffer;
    protected IntBuffer mColorBuffer;
    protected IntBuffer mNormalBuffer;
    protected Buffer mIndexBuffer;
    protected int mNumIndices = -1;

    /**
     * Constructs a Shape.
     * 
     * @param primitive a GL primitive type understood by glDrawElements,
     * such as GL10.GL_TRIANGLES
     * @param indexDatatype the GL datatype for the  index buffer, such as
     * GL10.GL_UNSIGNED_SHORT
     * @param emitTextureCoordinates true to enable use of the texture
     * coordinate buffer
     * @param emitNormals true to enable use of the normal buffer
     * @param emitColors true to enable use of the color buffer
     */
    protected Shape(int primitive,
        int indexDatatype,
        boolean emitTextureCoordinates,
        boolean emitNormals,
        boolean emitColors) {
        mPrimitive = primitive;
        mIndexDatatype = indexDatatype;
        mEmitTextureCoordinates = emitTextureCoordinates;
        mEmitNormals = emitNormals;
        mEmitColors = emitColors;
    }

    /**
     * Converts the given floating-point value to fixed-point.
     */
    public static int toFixed(float x) {
        return (int) (x * 65536.0);
    }

    /**
     * Converts the given fixed-point value to floating-point.
     */
    public static float toFloat(int x) {
        return (float) (x / 65536.0);
    }

    /**
     * Computes the cross-product of two vectors p and q and places
     * the result in out. 
     */
    public static void cross(float[] p, float[] q, float[] out) {
        out[0] = p[1] * q[2] - p[2] * q[1];
        out[1] = p[2] * q[0] - p[0] * q[2];
        out[2] = p[0] * q[1] - p[1] * q[0];
    }

    /**
     * Returns the length of a vector, given as three floats.
     */
    public static float length(float vx, float vy, float vz) {
        return (float) Math.sqrt(vx * vx + vy * vy + vz * vz);
    }

    /**
     * Returns the length of a vector, given as an array of three floats.
     */
    public static float length(float[] v) { 
        return length(v[0], v[1], v[2]);
    }

    /**
     * Normalizes the given vector of three floats to have length == 1.0.
     * Vectors with length zero are unaffected.
     */
    public static void normalize(float[] v) {
        float length = length(v);
        if (length != 0.0f) {
            float norm = 1.0f / length;
            v[0] *= norm;
            v[1] *= norm;
            v[2] *= norm;
        }
    }

    /**
     * Returns the number of triangles associated with this shape.
     */
    public int getNumTriangles() {
        if (mPrimitive == GL10.GL_TRIANGLES) {
            return mIndexBuffer.capacity() / 3;
        } else if (mPrimitive == GL10.GL_TRIANGLE_STRIP) {
            return mIndexBuffer.capacity() - 2;
        }
        return 0;
    }
    
    /**
     * Copies the given data into the instance
     * variables mVertexBuffer, mTexcoordBuffer, mNormalBuffer, mColorBuffer,
     * and mIndexBuffer.
     * 
     * @param vertices an array of fixed-point vertex coordinates
     * @param texcoords an array of fixed-point texture coordinates
     * @param normals an array of fixed-point normal vector coordinates
     * @param colors an array of fixed-point color channel values
     * @param indices an array of short indices
     */
    public void allocateBuffers(int[] vertices, int[] texcoords, int[] normals,
        int[] colors, short[] indices) {
        allocate(vertices, texcoords, normals, colors);
        
        ByteBuffer ibb =
            ByteBuffer.allocateDirect(indices.length * SHORT_BYTES);
        ibb.order(ByteOrder.nativeOrder());
        ShortBuffer shortIndexBuffer = ibb.asShortBuffer();
        shortIndexBuffer.put(indices);
        shortIndexBuffer.position(0);
        this.mIndexBuffer = shortIndexBuffer;
    }
    
    /**
     * Copies the given data into the instance
     * variables mVertexBuffer, mTexcoordBuffer, mNormalBuffer, mColorBuffer,
     * and mIndexBuffer.
     * 
     * @param vertices an array of fixed-point vertex coordinates
     * @param texcoords an array of fixed-point texture coordinates
     * @param normals an array of fixed-point normal vector coordinates
     * @param colors an array of fixed-point color channel values
     * @param indices an array of int indices
     */
    public void allocateBuffers(int[] vertices, int[] texcoords, int[] normals,
        int[] colors, int[] indices) {
        allocate(vertices, texcoords, normals, colors);
        
        ByteBuffer ibb =
            ByteBuffer.allocateDirect(indices.length * INT_BYTES);
        ibb.order(ByteOrder.nativeOrder());
        IntBuffer intIndexBuffer = ibb.asIntBuffer();
        intIndexBuffer.put(indices);
        intIndexBuffer.position(0);
        this.mIndexBuffer = intIndexBuffer;
    }
    
    /**
     * Allocate the vertex, texture coordinate, normal, and color buffer.
     */
    private void allocate(int[] vertices, int[] texcoords, int[] normals,
        int[] colors) {
        ByteBuffer vbb =
            ByteBuffer.allocateDirect(vertices.length * INT_BYTES);
        vbb.order(ByteOrder.nativeOrder());
        mVertexBuffer = vbb.asIntBuffer();
        mVertexBuffer.put(vertices);
        mVertexBuffer.position(0);

        if ((texcoords != null) && mEmitTextureCoordinates) {
            ByteBuffer tbb =
                ByteBuffer.allocateDirect(texcoords.length * INT_BYTES);
            tbb.order(ByteOrder.nativeOrder());
            mTexcoordBuffer = tbb.asIntBuffer();
            mTexcoordBuffer.put(texcoords);
            mTexcoordBuffer.position(0);
        }

        if ((normals != null) && mEmitNormals) {
            ByteBuffer nbb =
                ByteBuffer.allocateDirect(normals.length * INT_BYTES);
            nbb.order(ByteOrder.nativeOrder());
            mNormalBuffer = nbb.asIntBuffer();
            mNormalBuffer.put(normals);
            mNormalBuffer.position(0);
        }

        if ((colors != null) && mEmitColors) {
            ByteBuffer cbb =
                ByteBuffer.allocateDirect(colors.length * INT_BYTES);
            cbb.order(ByteOrder.nativeOrder());
            mColorBuffer = cbb.asIntBuffer();
            mColorBuffer.put(colors);
            mColorBuffer.position(0);
        }
    }

    /**
     * Draws the shape to the given OpenGL ES 1.0 context.  Texture coordinates,
     * normals, and colors are emitted according the the preferences set for
     * this shape.
     */
    public void draw(GL10 gl) {
        gl.glVertexPointer(3, GL10.GL_FIXED, 0, mVertexBuffer);
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

        if (mEmitTextureCoordinates) {
            gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
            gl.glTexCoordPointer(2, GL10.GL_FIXED, 0, mTexcoordBuffer);
            gl.glEnable(GL10.GL_TEXTURE_2D);
        } else {
            gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
            gl.glDisable(GL10.GL_TEXTURE_2D);
        }

        if (mEmitNormals) {
            gl.glEnableClientState(GL10.GL_NORMAL_ARRAY);
            gl.glNormalPointer(GL10.GL_FIXED, 0, mNormalBuffer);
        } else {
            gl.glDisableClientState(GL10.GL_NORMAL_ARRAY);
        }

        if (mEmitColors) {
            gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
            gl.glColorPointer(4, GL10.GL_FIXED, 0, mColorBuffer);
        } else {
            gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
        }

        gl.glDrawElements(mPrimitive,
                          mNumIndices > 0 ? mNumIndices : mIndexBuffer.capacity(),
                          mIndexDatatype,
                          mIndexBuffer);
    }
}