glview.java.svn-base

google android code package

/*
 * Copyright (C) 2006-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.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import javax.microedition.khronos.opengles.GL10;

import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.KeyEvent;

class Message {

    private String mText;
    private long mExpirationTime;

    public Message(String text, long expirationTime) {
        this.mText = text;
        this.mExpirationTime = expirationTime;
    }

    public String getText() {
        return mText;
    }

    public long getExpirationTime() {
        return mExpirationTime;
    }
}

/**
 * A helper class to simplify writing an Activity that renders using
 * OpenGL ES.
 *
 * <p> A GLView object stores common elements of GL state and allows
 * them to be modified interactively.  This is particularly useful for
 * determining the proper settings of parameters such as the view
 * frustum and light intensities during application development.
 *
 * <p> A GLView is not an actual View; instead, it is meant to be
 * called from within a View to perform event processing on behalf of the
 * actual View.
 *
 * <p> By passing key events to the GLView object from the View,
 * the application can automatically allow certain parameters to
 * be user-controlled from the keyboard.  Key events may be passed as
 * shown below:
 *
 * <pre>
 * GLView mGlView = new GLView();
 *
 * public boolean onKeyDown(int keyCode, KeyEvent event) {
 *     // Hand the key to the GLView object first
 *     if (mGlView.processKey(keyCode)) {
 *         return;
 *     }
 *  
 *     switch (keyCode) {
 *     case KeyEvent.KEY_CODE_X:
 *         // perform app processing
 *         break;
 *     
 *     default:
 *         super.onKeyDown(keyCode, event);
 *         break;
 *     }
 * }
 * </pre>
 *
 * <p> During drawing of a frame, the GLView object should be given the
 * opportunity to manage GL parameters as shown below:
 * 
 * OpenGLContext mGLContext; // initialization not shown
 * int mNumTrianglesDrawn = 0;
 * 
 * protected void onDraw(Canvas canvas) {
 *     int w = getWidth();
 *     int h = getHeight();
 *         
 *     float ratio = (float) w / h;
 *     mGLView.setAspectRatio(ratio);
 *
 *     GL10 gl = (GL10) mGLContext.getGL();
 *     mGLContext.waitNative(canvas, this);
 *     
 *     // Enable a light for the GLView to manipulate
 *     gl.glEnable(GL10.GL_LIGHTING);
 *     gl.glEnable(GL10.GL_LIGHT0);
 *         
 *     // Allow the GLView to set GL parameters
 *     mGLView.setTextureParameters(gl);
 *     mGLView.setProjection(gl);
 *     mGLView.setView(gl);
 *     mGLView.setLights(gl, GL10.GL_LIGHT0);
 *         
 *     // Draw some stuff (not shown)
 *     mNumTrianglesDrawn += <num triangles just drawn>;
 *     
 *     // Wait for GL drawing to complete
 *     mGLContext.waitGL();
 *     
 *     // Inform the GLView of what was drawn, and ask it to display statistics
 *     mGLView.setNumTriangles(mNumTrianglesDrawn);
 *     mGLView.showMessages(canvas);
 *     mGLView.showStatistics(canvas, w);
 * }      
 * </pre>
 *
 * <p> At the end of each frame, following the call to
 * GLContext.waitGL, the showStatistics and showMessages methods
 * will cause additional information to be displayed.
 *
 * <p> To enter the interactive command mode, the 'tab' key must be
 * pressed twice in succession.  A subsequent press of the 'tab' key
 * exits the interactive command mode.  Entering a multi-letter code
 * sets the parameter to be modified. The 'newline' key erases the
 * current code, and the 'del' key deletes the last letter of
 * the code. The parameter value may be modified by pressing the
 * keypad left or up to decrement the value and right or down to
 * increment the value.  The current value will be displayed as an
 * overlay above the GL rendered content.
 * 
 * <p> The supported keyboard commands are as follows:
 *
 * <ul>
 * <li>     h - display a list of commands
 * <li>    fn - near frustum 
 * <li>    ff - far frustum 
 * <li>    tx - translate x
 * <li>    ty - translate y
 * <li>    tz - translate z
 * <li>     z - zoom (frustum size)
 * <li>    la - ambient light (all RGB channels)
 * <li>   lar - ambient light red channel
 * <li>   lag - ambient light green channel
 * <li>   lab - ambient light blue channel
 * <li>    ld - diffuse light (all RGB channels)
 * <li>   ldr - diffuse light red channel
 * <li>   ldg - diffuse light green channel
 * <li>   ldb - diffuse light blue channel
 * <li>    ls - specular light (all RGB channels)
 * <li>   lsr - specular light red channel
 * <li>   lsg - specular light green channel
 * <li>   lsb - specular light blue channel
 * <li>   lma - light model ambient (all RGB channels)
 * <li>  lmar - light model ambient light red channel
 * <li>  lmag - light model ambient green channel
 * <li>  lmab - light model ambient blue channel
 * <li>  tmin - texture min filter
 * <li>  tmag - texture mag filter
 * <li>  tper - texture perspective correction
 * </ul>
 * 
 * {@hide}
 */
public class GLView {

    private static final int DEFAULT_DURATION_MILLIS = 1000;
    private static final int STATE_KEY = KeyEvent.KEYCODE_TAB;
    private static final int HAVE_NONE = 0;
    private static final int HAVE_ONE = 1;
    private static final int HAVE_TWO = 2;

    private static final float MESSAGE_Y_SPACING = 12.0f;

    private int mState = HAVE_NONE;

    private static final int NEAR_FRUSTUM  = 0;
    private static final int FAR_FRUSTUM   = 1;
    private static final int TRANSLATE_X   = 2;
    private static final int TRANSLATE_Y   = 3;
    private static final int TRANSLATE_Z   = 4;
    private static final int ZOOM_EXPONENT = 5;

    private static final int AMBIENT_INTENSITY = 6;
    private static final int AMBIENT_RED = 7;
    private static final int AMBIENT_GREEN = 8;
    private static final int AMBIENT_BLUE = 9;

    private static final int DIFFUSE_INTENSITY = 10;
    private static final int DIFFUSE_RED = 11;
    private static final int DIFFUSE_GREEN = 12;
    private static final int DIFFUSE_BLUE = 13;

    private static final int SPECULAR_INTENSITY = 14;
    private static final int SPECULAR_RED = 15;
    private static final int SPECULAR_GREEN = 16;
    private static final int SPECULAR_BLUE = 17;

    private static final int LIGHT_MODEL_AMBIENT_INTENSITY = 18;
    private static final int LIGHT_MODEL_AMBIENT_RED = 19;
    private static final int LIGHT_MODEL_AMBIENT_GREEN = 20;
    private static final int LIGHT_MODEL_AMBIENT_BLUE = 21;

    private static final int TEXTURE_MIN_FILTER = 22;
    private static final int TEXTURE_MAG_FILTER = 23;
    private static final int TEXTURE_PERSPECTIVE_CORRECTION = 24;

    private static final String[] commands = { 
        "fn",
        "ff",
        "tx",
        "ty",
        "tz",
        "z",
        "la", "lar", "lag", "lab",
        "ld", "ldr", "ldg", "ldb",
        "ls", "lsr", "lsg", "lsb",
        "lma", "lmar", "lmag", "lmab",
        "tmin", "tmag", "tper"
   };

    private static final String[] labels = {
        "Near Frustum",
        "Far Frustum",
        "Translate X",
        "Translate Y",
        "Translate Z",
        "Zoom",
        "Ambient Intensity",
        "Ambient Red",
        "Ambient Green",
        "Ambient Blue",
        "Diffuse Intensity",
        "Diffuse Red",
        "Diffuse Green",
        "Diffuse Blue",
        "Specular Intenstity",
        "Specular Red",
        "Specular Green",
        "Specular Blue",
        "Light Model Ambient Intensity",
        "Light Model Ambient Red",
        "Light Model Ambient Green",
        "Light Model Ambient Blue",
        "Texture Min Filter",
        "Texture Mag Filter",
        "Texture Perspective Correction",
    };

    private static final float[] defaults = {
        5.0f, 100.0f,
        0.0f, 0.0f, -50.0f,
        0,
        0.125f,	1.0f, 1.0f, 1.0f,
        0.125f,	1.0f, 1.0f, 1.0f,
        0.125f,	1.0f, 1.0f, 1.0f,
        0.125f,	1.0f, 1.0f, 1.0f,
        GL10.GL_NEAREST, GL10.GL_NEAREST,
        GL10.GL_FASTEST
    };

    private static final float[] increments = {
        0.01f, 0.5f,
        0.125f, 0.125f, 0.125f,
        1.0f,
        0.03125f, 0.1f, 0.1f, 0.1f,
        0.03125f, 0.1f, 0.1f, 0.1f,
        0.03125f, 0.1f, 0.1f, 0.1f,
        0.03125f, 0.1f, 0.1f, 0.1f,
        0, 0, 0
    };

    private float[] params = new float[commands.length];

    private static final float mZoomScale = 0.109f;
    private static final float mZoomBase  = 1.01f;

    private int             mParam = -1;
    private float           mIncr = 0;

    private Paint           mPaint = new Paint();

    private float           mAspectRatio = 1.0f;

    private float           mZoom;

    // private boolean         mPerspectiveCorrection = false;
    // private int             mTextureMinFilter = GL10.GL_NEAREST;
    // private int             mTextureMagFilter = GL10.GL_NEAREST;

    // Counters for FPS calculation
    private boolean         mDisplayFPS = false;
    private boolean         mDisplayCounts = false;
    private int             mFramesFPS = 10;
    private long[]          mTimes = new long[mFramesFPS];
    private int             mTimesIdx = 0;

    private Map<String,Message> mMessages = new HashMap<String,Message>();

    /**
     * Constructs a new GLView.
     */
    public GLView() {
        mPaint.setColor(0xffffffff);
        reset();
    }

    /**
     * Sets the aspect ratio (width/height) of the screen.
     *
     * @param aspectRatio the screen width divided by the screen height
     */
    public void setAspectRatio(float aspectRatio) {
        this.mAspectRatio = aspectRatio;
    }
    
    /**
     * Sets the overall ambient light intensity.  This intensity will
     * be used to modify the ambient light value for each of the red,
     * green, and blue channels passed to glLightfv(...GL_AMBIENT...).
     * The default value is 0.125f.
     *
     * @param intensity a floating-point value controlling the overall
     * ambient light intensity.
     */
    public void setAmbientIntensity(float intensity) {
        params[AMBIENT_INTENSITY] = intensity;
    }

    /**
     * Sets the light model ambient intensity.  This intensity will be
     * used to modify the ambient light value for each of the red,
     * green, and blue channels passed to
     * glLightModelfv(GL_LIGHT_MODEL_AMBIENT...).  The default value
     * is 0.125f.
     *
     * @param intensity a floating-point value controlling the overall
     * light model ambient intensity.
     */
    public void setLightModelAmbientIntensity(float intensity) {
        params[LIGHT_MODEL_AMBIENT_INTENSITY] = intensity;
    }

    /**
     * Sets the ambient color for the red, green, and blue channels
     * that will be multiplied by the value of setAmbientIntensity and
     * passed to glLightfv(...GL_AMBIENT...).  The default values are
     * {1, 1, 1}.
     *
     * @param ambient an arry of three floats containing ambient
     * red, green, and blue intensity values.
     */
    public void setAmbientColor(float[] ambient) {
        params[AMBIENT_RED]   = ambient[0];
        params[AMBIENT_GREEN] = ambient[1];
        params[AMBIENT_BLUE]  = ambient[2];
    }

    /**
     * Sets the overall diffuse light intensity.  This intensity will
     * be used to modify the diffuse light value for each of the red,
     * green, and blue channels passed to glLightfv(...GL_DIFFUSE...).
     * The default value is 0.125f.
     *
     * @param intensity a floating-point value controlling the overall
     * ambient light intensity.
     */
    public void setDiffuseIntensity(float intensity) {
        params[DIFFUSE_INTENSITY] = intensity;
    }

    /**
     * Sets the diffuse color for the red, green, and blue channels
     * that will be multiplied by the value of setDiffuseIntensity and
     * passed to glLightfv(...GL_DIFFUSE...).  The default values are
     * {1, 1, 1}.
     *
     * @param diffuse an array of three floats containing diffuse
     * red, green, and blue intensity values.
     */
    public void setDiffuseColor(float[] diffuse) {
        params[DIFFUSE_RED]   = diffuse[0];
        params[DIFFUSE_GREEN] = diffuse[1];
        params[DIFFUSE_BLUE]  = diffuse[2];
    }

    /**
     * Sets the overall specular light intensity.  This intensity will
     * be used to modify the diffuse light value for each of the red,
     * green, and blue channels passed to glLightfv(...GL_SPECULAR...).
     * The default value is 0.125f.
     *
     * @param intensity a floating-point value controlling the overall
     * ambient light intensity.
     */
    public void setSpecularIntensity(float intensity) {
        params[SPECULAR_INTENSITY] = intensity;
    }

    /**
     * Sets the specular color for the red, green, and blue channels
     * that will be multiplied by the value of setSpecularIntensity and
     * passed to glLightfv(...GL_SPECULAR...).  The default values are
     * {1, 1, 1}.
     *
     * @param specular an array of three floats containing specular
     * red, green, and blue intensity values.
     */
    public void setSpecularColor(float[] specular) {
        params[SPECULAR_RED]   = specular[0];
        params[SPECULAR_GREEN] = specular[1];
        params[SPECULAR_BLUE]  = specular[2];
    }

    /**
     * Returns the current X translation of the modelview
     * transformation as passed to glTranslatef.  The default value is
     * 0.0f.
     *
     * @return the X modelview translation as a float.
     */
    public float getTranslateX() {
        return params[TRANSLATE_X];
    }

    /**
     * Returns the current Y translation of the modelview
     * transformation as passed to glTranslatef.  The default value is
     * 0.0f.
     *
     * @return the Y modelview translation as a float.
     */
    public float getTranslateY() {
        return params[TRANSLATE_Y];
    }

    /**
     * Returns the current Z translation of the modelview
     * transformation as passed to glTranslatef.  The default value is
     * -50.0f.
     *
     * @return the Z modelview translation as a float.
     */
    public float getTranslateZ() {
        return params[TRANSLATE_Z];
    }

    /**
     * Sets the position of the near frustum clipping plane as passed
     * to glFrustumf.  The default value is 5.0f;
     *
     * @param nearFrustum the near frustum clipping plane distance as
     * a float.
     */