samples/GlobalTime/src/com/android/globaltime/Shape.java - platform/development - Git at Google

 /*
  * Copyright (C) 2007 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 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);
     }
 }
	/*
	* Copyright (C) 2007 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 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);
	}
	}