glview.java

google android code package

    public void setNearFrustum(float nearFrustum) {
        params[NEAR_FRUSTUM] = nearFrustum;
    }

    /**
     * Sets the position of the far frustum clipping plane as passed
     * to glFrustumf.  The default value is 100.0f;
     *
     * @param farFrustum the far frustum clipping plane distance as a
     * float.
     */
    public void setFarFrustum(float farFrustum) {
        params[FAR_FRUSTUM] = farFrustum;
    }

    private void computeZoom() {
        mZoom = mZoomScale*(float)Math.pow(mZoomBase, -params[ZOOM_EXPONENT]);
    }

    /**
     * Resets all parameters to their default values.
     */
    public void reset() {
        for (int i = 0; i < params.length; i++) {
            params[i] = defaults[i];
        }
        computeZoom();
    }

    private void removeExpiredMessages() {
        long now = System.currentTimeMillis();

        List<String> toBeRemoved = new ArrayList<String>();

        Iterator<String> keyIter = mMessages.keySet().iterator();
        while (keyIter.hasNext()) {
            String key = keyIter.next();
            Message msg = mMessages.get(key);
            if (msg.getExpirationTime() < now) {
                toBeRemoved.add(key);
            }
        }

        Iterator<String> tbrIter = toBeRemoved.iterator();
        while (tbrIter.hasNext()) {
            String key = tbrIter.next();
            mMessages.remove(key);
        }
    }
    
    /**
     * Displays the message overlay on the given Canvas.  The
     * GLContext.waitGL method should be called prior to calling this
     * method.  The interactive command display is drawn by this
     * method.
     *
     * @param canvas the Canvas on which messages are to appear.
     */
    public void showMessages(Canvas canvas) {
        removeExpiredMessages();

        float y = 10.0f;

        List<String> l = new ArrayList<String>();
        l.addAll(mMessages.keySet());
        Collections.sort(l);

        Iterator<String> iter = l.iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            String text = mMessages.get(key).getText();
            canvas.drawText(text, 10.0f, y, mPaint);
            y += MESSAGE_Y_SPACING;
        }
    }

    private int mTriangles;

    /**
     * Sets the number of triangles drawn in the previous frame for
     * display by the showStatistics method.  The number of triangles
     * is not computed by GLView but must be supplied by the
     * calling Activity.
     *
     * @param triangles an Activity-supplied estimate of the number of 
     * triangles drawn in the previous frame.
     */
    public void setNumTriangles(int triangles) {
        this.mTriangles = triangles;
    }

    /**
     * Displays statistics on frames and triangles per second. The
     * GLContext.waitGL method should be called prior to calling this
     * method.
     *
     * @param canvas the Canvas on which statistics are to appear.
     * @param width the width of the Canvas.
     */
    public void showStatistics(Canvas canvas, int width) {	
        long endTime = mTimes[mTimesIdx] = System.currentTimeMillis();
        mTimesIdx = (mTimesIdx + 1) % mFramesFPS;

        float th = mPaint.getTextSize();

        if (mDisplayFPS) {
            // Use end time from mFramesFPS frames ago
            long startTime = mTimes[mTimesIdx];
            String fps = "" + (1000.0f*mFramesFPS/(endTime - startTime));

            // Normalize fps to XX.XX format
            if (fps.indexOf(".") == 1) {
                fps = " " + fps;
            }
            int len = fps.length();
            if (len == 2) {
                fps += ".00";
            } else if (len == 4) {
                fps += "0";
            } else if (len > 5) {
                fps = fps.substring(0, 5);
            }

            canvas.drawText(fps + " fps", width - 60.0f, 10.0f, mPaint);
        }

        if (mDisplayCounts) {
            canvas.drawText(mTriangles + " triangles",
                            width - 100.0f, 10.0f + th + 5, mPaint);
        }
    }

    private void addMessage(String key, String text, int durationMillis) {
        long expirationTime = System.currentTimeMillis() + durationMillis;

        mMessages.put(key, new Message(text, expirationTime));
    }

    private void addMessage(String key, String text) {
        addMessage(key, text, DEFAULT_DURATION_MILLIS);
    }

    private void addMessage(String text) {
        addMessage(text, text, DEFAULT_DURATION_MILLIS);
    }

    private void clearMessages() {
        mMessages.clear();
    }

    String command = "";

    private void toggleFilter() {
        if (params[mParam] == GL10.GL_NEAREST) {
            params[mParam] = GL10.GL_LINEAR;
        } else {
            params[mParam] = GL10.GL_NEAREST;
        }
        addMessage(commands[mParam],
                   "Texture " + 
                   (mParam == TEXTURE_MIN_FILTER ? "min" : "mag") +
                   " filter = " +
                   (params[mParam] == GL10.GL_NEAREST ?
                    "nearest" : "linear"));
    }

    private void togglePerspectiveCorrection() {
        if (params[mParam] == GL10.GL_NICEST) {
            params[mParam] = GL10.GL_FASTEST;
        } else {
            params[mParam] = GL10.GL_NICEST;
        }
        addMessage(commands[mParam],
                   "Texture perspective correction = " +
                   (params[mParam] == GL10.GL_FASTEST ?
                    "fastest" : "nicest"));
    }

    private String valueString() {
        if (mParam == TEXTURE_MIN_FILTER ||
            mParam == TEXTURE_MAG_FILTER) {
            if (params[mParam] == GL10.GL_NEAREST) {
                return "nearest";
            }
            if (params[mParam] == GL10.GL_LINEAR) {
                return "linear";
            }
        }
        if (mParam == TEXTURE_PERSPECTIVE_CORRECTION) {
            if (params[mParam] == GL10.GL_FASTEST) {
                return "fastest";
            }
            if (params[mParam] == GL10.GL_NICEST) {
                return "nicest";
            }
        }
        return "" + params[mParam];
    }

    /**
     * 
     * @return true if the view 
     */
    public boolean hasMessages() {
        return mState == HAVE_TWO || mDisplayFPS || mDisplayCounts;
    }
    
    /**
     * Process a key stroke.  The calling Activity should pass all
     * keys from its onKeyDown method to this method.  If the key is
     * part of a GLView command, true is returned and the calling
     * Activity should ignore the key event.  Otherwise, false is
     * returned and the calling Activity may process the key event
     * normally.
     *
     * @param keyCode the key code as passed to Activity.onKeyDown.
     *
     * @return true if the key is part of a GLView command sequence,
     * false otherwise.
     */
    public boolean processKey(int keyCode) {
        // Pressing the state key twice enters the UI
        // Pressing it again exits the UI
        if ((keyCode == STATE_KEY) || 
            (keyCode == KeyEvent.KEYCODE_SLASH) || 
            (keyCode == KeyEvent.KEYCODE_PERIOD))
        {
            mState = (mState + 1) % 3;
            if (mState == HAVE_NONE) {
                clearMessages();
            }
            if (mState == HAVE_TWO) {
                clearMessages();
                addMessage("aaaa", "GL", Integer.MAX_VALUE);
                addMessage("aaab", "", Integer.MAX_VALUE);
                command = "";
            }
            return true;
        } else {
            if (mState == HAVE_ONE) {
                mState = HAVE_NONE;
                return false;
            }
        }

        // If we're not in the UI, exit without handling the key
        if (mState != HAVE_TWO) {
            return false;
        }

        if (keyCode == KeyEvent.KEYCODE_ENTER) {
            command = "";
        } else if (keyCode == KeyEvent.KEYCODE_DEL) {
            if (command.length() > 0) {
                command = command.substring(0, command.length() - 1);
            }

        } else if (keyCode >= KeyEvent.KEYCODE_A &&
                   keyCode <= KeyEvent.KEYCODE_Z) {
            command += "" + (char)(keyCode - KeyEvent.KEYCODE_A + 'a');
        }

        addMessage("aaaa", "GL " + command, Integer.MAX_VALUE);

        if (command.equals("h")) {
            addMessage("aaaa", "GL", Integer.MAX_VALUE);
            addMessage("h - help");
            addMessage("fn/ff - frustum near/far clip Z");
            addMessage("la/lar/lag/lab - abmient intensity/r/g/b");
            addMessage("ld/ldr/ldg/ldb - diffuse intensity/r/g/b");
            addMessage("ls/lsr/lsg/lsb - specular intensity/r/g/b");
            addMessage("s - toggle statistics display");
            addMessage("tmin/tmag - texture min/mag filter");
            addMessage("tpersp - texture perspective correction");
            addMessage("tx/ty/tz - view translate x/y/z");
            addMessage("z - zoom");
            command = "";
            return true;
        } else if (command.equals("s")) {
            mDisplayCounts = !mDisplayCounts;
            mDisplayFPS = !mDisplayFPS;
            command = "";
            return true;
        }

        mParam = -1;
        for (int i = 0; i < commands.length; i++) {
            if (command.equals(commands[i])) {
                mParam = i;
                mIncr = increments[i];
            }
        }
        if (mParam == -1) {
            return true;
        }

        boolean addMessage = true;

        // Increment or decrement
        if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT ||
            keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
            if (mParam == ZOOM_EXPONENT) {
                params[mParam] += mIncr;
                computeZoom();
            } else if ((mParam == TEXTURE_MIN_FILTER) ||
                       (mParam == TEXTURE_MAG_FILTER)) {
                toggleFilter();
            } else if (mParam == TEXTURE_PERSPECTIVE_CORRECTION) {
                togglePerspectiveCorrection();
            } else {
                params[mParam] += mIncr;
            }
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_UP ||
                   keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
            if (mParam == ZOOM_EXPONENT) {
                params[mParam] -= mIncr;
                computeZoom();
            } else if ((mParam == TEXTURE_MIN_FILTER) ||
                       (mParam == TEXTURE_MAG_FILTER)) {
                toggleFilter();
            } else if (mParam == TEXTURE_PERSPECTIVE_CORRECTION) {
                togglePerspectiveCorrection();
            } else {
                params[mParam] -= mIncr;
            }
        }
	
        if (addMessage) {
            addMessage(commands[mParam],
                       labels[mParam] + ": " + valueString());
        }

        return true;
    }

    /**
     * Zoom in by a given number of steps.  A negative value of steps
     * zooms out.  Each step zooms in by 1%.
     *
     * @param steps the number of steps to zoom by.
     */
    public void zoom(int steps) {
        params[ZOOM_EXPONENT] += steps;
        computeZoom();
    }
		
    /**
     * Set the projection matrix using glFrustumf.  The left and right
     * clipping planes are set at -+(aspectRatio*zoom), the bottom and
     * top clipping planes are set at -+zoom, and the near and far
     * clipping planes are set to the values set by setNearFrustum and
     * setFarFrustum or interactively.
     *
     * <p> GL side effects:
     * <ul>
     *    <li>overwrites the matrix mode</li>
     *    <li>overwrites the projection matrix</li>
     * </ul>
     *
     * @param gl a GL10 instance whose projection matrix is to be modified.
     */
    public void setProjection(GL10 gl) {
        gl.glMatrixMode(GL10.GL_PROJECTION);
        gl.glLoadIdentity();

        if (mAspectRatio >= 1.0f) {
            gl.glFrustumf(-mAspectRatio*mZoom, mAspectRatio*mZoom,
                          -mZoom, mZoom,
                          params[NEAR_FRUSTUM], params[FAR_FRUSTUM]);
        } else {
            gl.glFrustumf(-mZoom, mZoom,
                          -mZoom / mAspectRatio, mZoom / mAspectRatio,
                          params[NEAR_FRUSTUM], params[FAR_FRUSTUM]);
        }
    }

    /**
     * Set the modelview matrix using glLoadIdentity and glTranslatef.
     * The translation values are set interactively.
     *
     * <p> GL side effects:
     * <ul>
     * <li>overwrites the matrix mode</li>
     * <li>overwrites the modelview matrix</li>
     * </ul>
     *
     * @param gl a GL10 instance whose modelview matrix is to be modified.
     */
    public void setView(GL10 gl) {
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();

        // Move the viewpoint backwards
        gl.glTranslatef(params[TRANSLATE_X],
                        params[TRANSLATE_Y],
                        params[TRANSLATE_Z]);
    }

    /**
     * Sets texture parameters.
     *
     * <p> GL side effects:
     * <ul>
     * <li>sets the GL_PERSPECTIVE_CORRECTION_HINT</li>
     * <li>sets the GL_TEXTURE_MIN_FILTER texture parameter</li>
     * <li>sets the GL_TEXTURE_MAX_FILTER texture parameter</li>
     * </ul>
     *
     * @param gl a GL10 instance whose texture parameters are to be modified.
     */
    public void setTextureParameters(GL10 gl) {
        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,
                  (int)params[TEXTURE_PERSPECTIVE_CORRECTION]);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D,
                           GL10.GL_TEXTURE_MIN_FILTER,
                           params[TEXTURE_MIN_FILTER]);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D,
                           GL10.GL_TEXTURE_MAG_FILTER,
                           params[TEXTURE_MAG_FILTER]);
    }

    /**
     * Sets the lighting parameters for the given light.
     *
     * <p> GL side effects:
     * <ul>
     * <li>sets the GL_LIGHT_MODEL_AMBIENT intensities
     * <li>sets the GL_AMBIENT intensities for the given light</li>
     * <li>sets the GL_DIFFUSE intensities for the given light</li>
     * <li>sets the GL_SPECULAR intensities for the given light</li>
     * </ul>
     *
     * @param gl a GL10 instance whose texture parameters are to be modified.
     */
    public void setLights(GL10 gl, int lightNum) {
        float[] light = new float[4];
        light[3] = 1.0f;

        float lmi = params[LIGHT_MODEL_AMBIENT_INTENSITY];
        light[0] = params[LIGHT_MODEL_AMBIENT_RED]*lmi;
        light[1] = params[LIGHT_MODEL_AMBIENT_GREEN]*lmi;
        light[2] = params[LIGHT_MODEL_AMBIENT_BLUE]*lmi;
        gl.glLightModelfv(GL10.GL_LIGHT_MODEL_AMBIENT, light, 0);
	
        float ai = params[AMBIENT_INTENSITY];
        light[0] = params[AMBIENT_RED]*ai;
        light[1] = params[AMBIENT_GREEN]*ai;
        light[2] = params[AMBIENT_BLUE]*ai;
        gl.glLightfv(lightNum, GL10.GL_AMBIENT, light, 0);

        float di = params[DIFFUSE_INTENSITY];
        light[0] = params[DIFFUSE_RED]*di;
        light[1] = params[DIFFUSE_GREEN]*di;
        light[2] = params[DIFFUSE_BLUE]*di;
        gl.glLightfv(lightNum, GL10.GL_DIFFUSE, light, 0);

        float si = params[SPECULAR_INTENSITY];
        light[0] = params[SPECULAR_RED]*si;
        light[1] = params[SPECULAR_GREEN]*si;
        light[2] = params[SPECULAR_BLUE]*si;
        gl.glLightfv(lightNum, GL10.GL_SPECULAR, light, 0);
    }
}