Android Open Source - iwashi3d Matrix Stack

From Project

Back to project page iwashi3d.
License

The source code is released under:
Apache License
If you think the Android project iwashi3d listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

/*
 * Copyright (C) 2007 The Android Open Source Project
 *//  w w w  . j a  v a2 s .c  o m
 * 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.example.android.apis.graphics.spritetext;
package jp.co.qsdn.android.iwashi3d.util;

import android.opengl.Matrix;
import android.util.Log;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;

/**
 * A matrix stack, similar to OpenGL ES's internal matrix stack.
 */
public class MatrixStack {
  private static final String TAG = MatrixStack.class.getName();
  private static final boolean _debug = false;
  public MatrixStack() {
    commonInit(DEFAULT_MAX_DEPTH);
  }

  public MatrixStack(int maxDepth) {
    commonInit(maxDepth);
  }

  private void commonInit(int maxDepth) {
    mTop = 0;
    mMatrix = new float[maxDepth * MATRIX_SIZE];
    mTemp = new float[MATRIX_SIZE * 2];
    glLoadIdentity();
  }

  public void glFrustumf(float left, float right, float bottom, float top,
      float near, float far) {
    Matrix.frustumM(mMatrix, mTop, left, right, bottom, top, near, far);
  }

  public void glFrustumx(int left, int right, int bottom, int top, int near,
      int far) {
    glFrustumf(fixedToFloat(left),fixedToFloat(right),
        fixedToFloat(bottom), fixedToFloat(top),
        fixedToFloat(near), fixedToFloat(far));
  }

  public void glLoadIdentity() {
    Matrix.setIdentityM(mMatrix, mTop);
  }

  public void glLoadMatrixf(float[] m, int offset) {
    System.arraycopy(m, offset, mMatrix, mTop, MATRIX_SIZE);
  }

  public void glLoadMatrixf(FloatBuffer m) {
    m.get(mMatrix, mTop, MATRIX_SIZE);
  }

  public void glLoadMatrixx(int[] m, int offset) {
    for(int i = 0; i < MATRIX_SIZE; i++) {
      mMatrix[mTop + i] = fixedToFloat(m[offset + i]);
    }
  }

  public void glLoadMatrixx(IntBuffer m) {
    for(int i = 0; i < MATRIX_SIZE; i++) {
      mMatrix[mTop + i] = fixedToFloat(m.get());
    }
  }

  public void glMultMatrixf(float[] m, int offset) {
    System.arraycopy(mMatrix, mTop, mTemp, 0, MATRIX_SIZE);
    Matrix.multiplyMM(mMatrix, mTop, mTemp, 0, m, offset);
  }

  public void glMultMatrixf(FloatBuffer m) {
    m.get(mTemp, MATRIX_SIZE, MATRIX_SIZE);
    glMultMatrixf(mTemp, MATRIX_SIZE);
  }

  public void glMultMatrixx(int[] m, int offset) {
    for(int i = 0; i < MATRIX_SIZE; i++) {
      mTemp[MATRIX_SIZE + i] = fixedToFloat(m[offset + i]);
    }
    glMultMatrixf(mTemp, MATRIX_SIZE);
  }

  public void glMultMatrixx(IntBuffer m) {
    for(int i = 0; i < MATRIX_SIZE; i++) {
      mTemp[MATRIX_SIZE + i] = fixedToFloat(m.get());
    }
    glMultMatrixf(mTemp, MATRIX_SIZE);
  }

  public void glOrthof(float left, float right, float bottom, float top,
      float near, float far) {
    Matrix.orthoM(mMatrix, mTop, left, right, bottom, top, near, far);
  }

  public void glOrthox(int left, int right, int bottom, int top, int near,
      int far) {
    glOrthof(fixedToFloat(left), fixedToFloat(right),
        fixedToFloat(bottom), fixedToFloat(top),
        fixedToFloat(near), fixedToFloat(far));
  }

  public void glPopMatrix() {
    if (_debug) Log.d(TAG,"start glPopMatrix");
    preflight_adjust(-1);
    adjust(-1);
    if (_debug) Log.d(TAG,"end glPopMatrix");
  }

  public void glPushMatrix() {
    if (_debug) Log.d(TAG,"start glPushMatrix");
    preflight_adjust(1);
    System.arraycopy(mMatrix, mTop, mMatrix, mTop + MATRIX_SIZE,
        MATRIX_SIZE);
    adjust(1);
    if (_debug) Log.d(TAG,"end glPushMatrix");
  }

  public void glRotatef(float angle, float x, float y, float z) {
    Matrix.setRotateM(mTemp, 0, angle, x, y, z);
    System.arraycopy(mMatrix, mTop, mTemp, MATRIX_SIZE, MATRIX_SIZE);
    Matrix.multiplyMM(mMatrix, mTop, mTemp, MATRIX_SIZE, mTemp, 0);
  }

  public void glRotatex(int angle, int x, int y, int z) {
    glRotatef(angle, fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
  }

  public void glScalef(float x, float y, float z) {
    Matrix.scaleM(mMatrix, mTop, x, y, z);
  }

  public void glScalex(int x, int y, int z) {
    glScalef(fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
  }

  public void glTranslatef(float x, float y, float z) {
    Matrix.translateM(mMatrix, mTop, x, y, z);
  }

  public void glTranslatex(int x, int y, int z) {
    glTranslatef(fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
  }

  public void getMatrix(float[] dest, int offset) {
    System.arraycopy(mMatrix, mTop, dest, offset, MATRIX_SIZE);
  }

  private float fixedToFloat(int x) {
    return x * (1.0f / 65536.0f);
  }

  private void preflight_adjust(int dir) {
    int newTop = mTop + dir * MATRIX_SIZE;
    if (newTop < 0) {
      throw new IllegalArgumentException("stack underflow :[" + mTop + "][" + newTop + "]");
    }
    if (newTop + MATRIX_SIZE > mMatrix.length) {
      throw new IllegalArgumentException("stack overflow");
    }
  }

  private void adjust(int dir) {
    if (_debug) Log.d(TAG, "start adjust mTop:[" + mTop + "]");
    mTop += dir * MATRIX_SIZE;
    if (_debug) Log.d(TAG, "end adjust mTop:[" + mTop + "]");
  }

  private final static int DEFAULT_MAX_DEPTH = 32;
  private final static int MATRIX_SIZE = 16;
  private float[] mMatrix;
  private int mTop;
  private float[] mTemp;
}
Java Source Code List
