/* Mathematiques de l'informatique graphique    */
/* Direction en 3D                              */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Novembre 2012                                */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes3D.h"
#include "Direction3D.h"
#include "Position3D.h"

/* Constructeurs                                */

Direction3D::Direction3D(void):CoordonneesHomogenes3D(0.0,0.0,0.0,0.0) {
}

Direction3D::Direction3D(double x,double y,double z):CoordonneesHomogenes3D(x,y,z,0.0) {
}

Direction3D::Direction3D(Direction3D *p):CoordonneesHomogenes3D(p) {
}

Direction3D::Direction3D(Position3D *p1,Position3D *p2):CoordonneesHomogenes3D() {
  c[0] = p2->c[0]-p1->c[0];
  c[1] = p2->c[1]-p1->c[1];
  c[2] = p2->c[2]-p1->c[2];
  c[3] = 0.0;
}

/* Destructeur                                  */

Direction3D::~Direction3D(void) {
}

/* Methode de calcul de la norme                */

double Direction3D::norme(void) {
  return(sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2]));
}

/* Methode de normalisation                     */

double Direction3D::normalisation(void) {
  double d = norme();
  if ( d != 0.0 ) {
    c[0] /= d;
    c[1] /= d;
    c[2] /= d; }
  return(d);
}

/* Methode de calcul du produit scalaire        */
/* de deux directions                           */

double Direction3D::produitScalaire(Direction3D *d) {
  return(c[0]*d->c[0]+c[1]*d->c[1]+c[2]*d->c[2]);
}

/* Methode de calcul du produit vectoriel       */
/* de deux directions                           */

void Direction3D::produitVectoriel(Direction3D *d1,Direction3D *d2) {
  double x = d1->c[1]*d2->c[2] - d1->c[2]*d2->c[1];
  double y = d1->c[2]*d2->c[0] - d1->c[0]*d2->c[2];
  double z = d1->c[0]*d2->c[1] - d1->c[1]*d2->c[0];
  c[0] = x;
  c[1] = y;
  c[2] = z;
  c[3] = 0.0;
}

/* Methode de calcul du produit vectoriel       */
/* de this par une direction                    */

void Direction3D::produitVectoriel(Direction3D *d) {
  double x = c[1]*d->c[2] - c[2]*d->c[1];
  double y = c[2]*d->c[0] - c[0]*d->c[2];
  double z = c[0]*d->c[1] - c[1]*d->c[0];
  c[0] = x;
  c[1] = y;
  c[2] = z;
  c[3] = 0.0;
}

//////////////////////////////////////////////////

/* Methode de calcul de la direction            */
/* de reflexion d'un rayon lumineux             */

int Direction3D::reflexion(Direction3D *i,Direction3D *n) {
  double ps = i->produitScalaire(n);
  if ( ps < 0.0 )
    return(0);
  c[0] = 2.0*ps*n->c[0]-i->c[0];
  c[1] = 2.0*ps*n->c[1]-i->c[1];
  c[2] = 2.0*ps*n->c[2]-i->c[2];
  return(1);
}

/* Methode de calcul de la direction            */
/* de transmission d'un rayon lumineux          */

int Direction3D::transmission(Direction3D *i,Direction3D *n,double ni,double nt) {
  double ps = i->produitScalaire(n);
  if ( ps < 0.0 )
    return(0);
  double nr = ni/nt;
  double v = 1.0-nr*nr*(1.0-ps*ps);
  if ( v < 0.0 ) 
    return(0);
  v = nr*ps-sqrt(v);
  c[0] = v*n->c[0]-nr*i->c[0];
  c[1] = v*n->c[1]-nr*i->c[1];
  c[2] = v*n->c[2]-nr*i->c[2];
  return(1);
}

//////////////////////////////////////////////////