/* -*- coding: utf-8 -*- */
package demo1;
/**
 * Example code for the course "Tietokonegrafiikan perusteet" 2012
 * and 2013. Likely not useful for "production use".
 * 
 * Exercise 1: preliminary vector, matrix, and image classes.
 * 
 * @author Paavo Nieminen
 * 
 */

/** A class for 4-dimensional vectors. */
public class Vec4 {
    private static final int N_ROWS = 4;
    private double[] v = null;

    private Vec4(double[] shallowValues){
        v = shallowValues;
    }

    /** Become (0,0,0,1), "homogeneous 3d origin", by default. */
    public Vec4(){v = new double[N_ROWS]; v[3] = 1.0; }

    /** Representation of a 3D vector which is embedded on the "3-space
     * floating at w==1"
     */
    public Vec4(double x, double y, double z){
        v = new double[N_ROWS];
        v[0] = x; v[1]=y; v[2]=z; v[3] = 1.0;
    }

    public Vec4(double x, double y, double z, double w) {
        v = new double[N_ROWS];
        v[0] = x; v[1] = y; v[2] = z; v[3] = w;
    }

    /** Scalar product. (multiplies also the fourth element, which might
     * not be very useful with actual graphics codes; but we'll be doing
     * vertex scaling by matrix multiplications anyway)
     */
    public void times(double scal){
        for (int i=0; i<v.length; i++){
            v[i] *= scal;
        }
    }

    /** Sum. */
    public void plus(Vec4 other){
        for (int i=0; i<v.length; i++){
            v[i] += other.v[i];
        }
    }

    /** Negative sum. */
    public void minus(Vec4 other){
        for (int i=0; i<v.length; i++){
            v[i] -= other.v[i];
        }
    }

    /** Dot product. 
     *
     * HUOM: Kolmiulotteisen avaruuden vektoreiden homogeenisille
     * esityksille pistetulo on mielekäs tällaisenaan, mikäli
     * vektoreiden neljäs komponentti on 0. Tällaisia voi ajatella
     * "suuntina" tai "pisteinä, jotka ovat äärettömän
     * kaukana". Tavallaanhan palautuskaavan [x/w, y/w, z/w, 1] antama
     * 3d-vektori lähestyy äärettömän mittaista [x,y,z]:n suuntaista
     * vektoria, kun neljäs komponentti w lähestyy nollaa.
     */
    public double dot(Vec4 other){
        double res = 0.0;
        for (int i=0; i<v.length; i++){
            res += v[i] * other.v[i];
        }
        return res;
    }

    /** Cross product of the first 3 components; disregard 4th. 
     *
     * HUOM: On olemassa
     * myös neliulotteinen yleistys, jossa ristitulon kaltainen
     * operaatio tehdään kolmelle neliulotteiselle vektorille. Kuitenkin
     * meitä tulee kiinnostamaan lähinnä normaalivektorien laskeminen
     * 3D:ssä, joten tehdään ristitulo kahdelle vektorille ikään kuin ne
     * olisivat 3D-vektorien homogeenisia esityksiä, joissa viimeinen
     * eli w-koordinaatti on 1 (pisteille) tai 0 (suuntavektoreille);
     * oletetaan että se oli tässä vektorissa jo valmiiksi
     * asetettuna. Ristitulo sinänsä on järkevä lähinnä suuntavektoreille.
     * Normaalien laskemisessa kannattaa sitten huolehtia,
     * että operaation tulos skaalataan ykkösen mittaiseksi.
     * Tämä metodihan ei sitä tee.
     * 
     **/
    public static Vec4 cross3(Vec4 a, Vec4 b){
        double[] res = new double[N_ROWS];
        res[0] =   a.v[1] * b.v[2] - a.v[2] * b.v[1];
        res[1] = - a.v[0] * b.v[2] + a.v[2] * b.v[0];
        res[2] =   a.v[0] * b.v[1] - a.v[1] * b.v[0];  
        res[3] =   a.v[3];
        return new Vec4(res);
    }

    /** Multiply this vector with matrix A. */
    public void mulL(Mat4 A){
        double[] res = new double[N_ROWS];
        for(int i=0; i<N_ROWS; i++){
            for(int k=0; k<N_ROWS; k++){
                res[i] += A.at(i,k) * v[k];
            }
        }
        v = res;
    }

    /** A nicely formatted but unprecise printout. */
    public void prettyPrint(java.io.PrintStream ps){
        for (int i=0; i<v.length; i++){
            ps.printf("%6.2f ", v[i]);
        }
        ps.println();
    }

    /** Set 3 values; assume 4th needs no change. */
    public void set(double x, double y, double z) {
        this.v[0] = x;
        this.v[1] = y;
        this.v[2] = z;
    }

    /** Yields a zero direction vector (w=0). */
    public static Vec4 createDir() {
        return new Vec4(new double[N_ROWS]);
    }

    /** Access an individual coordinate value. */
    public double get(int i) {
        return v[i];
    }
    
    public Vec4 clone() {
        double[] cloned_v = v.clone();
        return new Vec4(cloned_v);
    }

    /** Divide vector by its euclidean norm. Observe that this 
     * is not really meaningful for homogeneous 3d points, but 
     * for directions is OK. 
     */
    public void normalize() {
        double norm = Math.sqrt(dot(this));
        times(1.0/norm);
    }

    /** Divide all elements by the fourth element, taking 
     * homogeneous coordinates back to the plane w=1. 
     */
    public void divBy4th() {
        v[0] /= v[3];
        v[1] /= v[3];
        v[2] /= v[3];
        v[3] /= v[3];
    }
}