vector3d.java

M3DEA (Mobile 3D Engine API) 手机3D引擎API

/*
 *M3DEA - MOBILE 3D ENGINE API
 *Copyright (C) 2006 Alexandre Watanabe         [e-mail]     
 *		     Diego de Freitas           [e-mail]
 *		     Paulo Rodrigo Priszculnik  [e-mail]
 *		     Rodrigo Arthur Lopes       [e-mail]
 *
 * This library is free software; you can redistribute it 
 * and/or modify it under the terms of the GNU Lesser General
 * Public License as published by the Free Software
 * Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for
 * more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite
 * 330, Boston, MA 02111-1307 USA
 *
 */

package m3dea.util;

/** Classe utilizada para realizar opera珲es vetorias b醩icas
 */
public class Vector3D
{    
    /** Construtor privado */
    private Vector3D(){}
    
    /** 
     * Calcula o produto escalar de dois vetores
     * @param v vetor1
     * @param u vetor2
     * @return retorna o produto escalar
     */
    public static float dotProduct(float[] v, float[] u)
    {
        return v[0] * u[0] + v[1] * u[1] + v[2] * u[2];
    }
    
    /** 
     * Calcula o produto vetorial de dois vetores
     * @param v vetor1
     * @param u vetor2
     * @return retorna um vetor que representa o produto vetorial
     */
    public static float[] crossProduct(float[] v, float[] u)
    {
        float[] newVec = {v[1] * u[2] - v[2] * u[1], v[2] * u[0] - v[0] * u[2], v[0] * u[1] - v[1] * u[0]};
        return newVec;
    }
    
    /**
     * Calcula comprimento do vetor
     * @param v vetor
     * @return Retorna comprimento do vetor
     */
    public static float length(float[] v)
    {
        return (float)Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    }
    
    /** 
     * Calcula proje玢o do vetor v sobre vetor u
     * @param v vetor1
     * @param u vetor2
     * @return retorna um vetor que representa a proje玢o do vetor v sobre vetor u
     */
    public static float[] project(float[] v, float[] u)
    {
        float lenU = length(u);
        float scalar = dotProduct(v, u) / (lenU * lenU);        
        return scalarMul(scalar, u);
    }
    
    /** 
     * Calcula vetor normal definido pelos vetores u e v 
     * @param v vetor1
     * @param u vetor2
     * @return retorna vetor normal de u e v 
     */
    public static float[] calcNormal(float[] v, float[] u)
    {
        float[] cross = crossProduct(v, u);
        return normalize(cross);
    }
    
    /** Normaliza o vetor v (comprimento = 1) 
     * @param v vetor
     * @return retorna vetor normalizado
     */
    public static float[] normalize(float[] v)
    {
        float len = length(v);
        float[] newVec = {v[0] / len, v[1] / len, v[2] / len};
        return newVec;
    }
    
    /** 
     * Calcula produto escalar do vetor v 
     * @param scalar valor a ser multiplicado
     * @param v vetor
     * @return retorna vetor calculado
     */
    public static float[] scalarMul(float scalar, float[] v)
    {
        float[] newVec = {v[0] * scalar, v[1] * scalar, v[2] * scalar};
        return newVec;
    }
    
    /** 
     * Subtrai dois vetores. v - u 
     * @param v vetor1
     * @param u vetor2
     * @return retorna vetor subtra韉o
     */
    public static float[] sub(float[] v, float[] u)
    {
        float[] newVec = {v[0] - u[0], v[1] - u[1], v[2] - u[2]};
        return newVec;
    }
    
    /** 
     * Soma dois vetores. v + u 
     * @param v vetor1
     * @param u vetor2
     * @return retorna vetor somado
     */
    public static float[] add(float[] v, float[] u)
    {
        float[] newVec = {v[0] + u[0], v[1] + u[1], v[2] + u[2]};
        return newVec;
    }
    
    /** 
     * Espelha vetor v no plano que tem vetor normal n 
     * @param v vetor diretor
     * @param n vetor normal
     * @return retorna vetor projetado
     */
    public static float[] mirror(float[] v, float[] n)
    {
        float[] u = Vector3D.project(v, n);
        return Vector3D.sub(v, Vector3D.scalarMul(2.0f, u));
    }
    
    /** 
     * Constr骾 um vetor
     * @param x valor de x
     * @param y valor de y
     * @param z valor de z
     * @return retorna vetor
     */
    public static float[] vector(float x, float y, float z)
    {
        float[] v = {x, y, z};
        return v;
    }
    
    /** 
     * Copia um vetor 
     * @param v vetor a ser copiado
     * @return retorna c髉ia do vetor
     */
    public static float[] copy(float[] v)
    {
        return new float[] {v[0], v[1], v[2]};
    }
    
    /** 
     * Representa玢o do vetor em String
     * @param v vetor
     * @return retorna representa玢o do vetor
     */
    public static String toString(float[] v)
    {
        return "(" + v[0] + ", " + v[1] + ", " + v[2] + ")";
    }
}