#include "algebre.h"


using namespace std;
/****************************************************************************/
//  En cas de bug :
static void erreur(string mesg) {
  cout << "----------------------------\n";
  cout << " plantage algebre.cpp :\n";
  cout << "   -- " << mesg << endl;
  exit(1);
}

/****************************************************************************/
GLboolean isNulEpsilon(float x) {
  return(fabs(x)<1.0E-07);
}

/****************************************************************************/


/****************************************************************************/
/** classe Vecteur3d
*/
void Vecteur3d::init() {
  resize(3);
}

Vecteur3d::Vecteur3d(float x, float y, float z, bool normalise) {
  init();
  set(x,y,z,normalise);
}

Vecteur3d::Vecteur3d(const Point3d &p1,const Point3d &p2) {
  init();
  set(p2.x()-p1.x(),p2.y()-p1.y(),p2.z()-p1.z());
}




void Vecteur3d::set(float x, float y, float z, bool normalise) {
  (*this)[0]=x;
  (*this)[1]=y;
  (*this)[2]=z;
  if (normalise) normaliser();
}

double Vecteur3d::norme() {
  return sqrt((*this)[0]*(*this)[0]+(*this)[1]*(*this)[1]+(*this)[2]*(*this)[2]);
}


void Vecteur3d::normaliser() {
  float d=sqrt((*this)[0]*(*this)[0]+(*this)[1]*(*this)[1]+(*this)[2]*(*this)[2]);
  if (isNulEpsilon(d)) {
    this->print();
    erreur("normalisation d'un vecteur nul !");
  }
  (*this)[0]/=d;
  (*this)[1]/=d;
  (*this)[2]/=d;
}

void Vecteur3d::scale(float kx,float ky,float kz) {
  set(x()*kx,y()*ky,z()*kz);
}

void Vecteur3d::scale(float k) {
  set(x()*k,y()*k,z()*k);
}

void Vecteur3d::translate(float xx,float yy, float zz) {
  set(x()+xx,y()+yy,z()+zz);
}


GLfloat *Vecteur3d::fv() const {
  return (GLfloat *)(&(this->front()));
}

void Vecteur3d::print() {
  Vecteur3d p=*this;
  cout << p[0] << "," << p[1] << "," << p[2] << endl;
}

void AVecteur3d::clean() {
  for(ItVecteur3d i=begin();i<end();i++) {
    delete (*i);
  }
}

/****************************************************************************/
/** opérations sur Vecteur3d et Point3d
*/
// normale à un segment (du plan z=0).
// !! précondition p1[z]=p2[z]=0
Vecteur3d normaleSegment(const Point3d &p1,const Point3d &p2) {
    Vecteur3d res;
    res.set(p1.y()-p2.y(),p2.x()-p1.x(),0.0,true);
    return res;
}

// effectue la moyenne entre 2 vecteurs (résultat normalisé)
Vecteur3d moyenne(Vecteur3d n1,Vecteur3d n2) {
    Vecteur3d res;
    res.set((n1.x()+n2.x())/2.0,(n1.y()+n2.y())/2.0,(n1.z()+n2.z())/2.0,true);
    return res;
}

Vecteur3d prodVect(const Vecteur3d &v1,const Vecteur3d &v2) {
   Vecteur3d n;
   n.set(v1.y()*v2.z()-v1.z()*v2.y(),
         v1.z()*v2.x()-v1.x()*v2.z(),
         v1.x()*v2.y()-v1.y()*v2.x());
   return n;
}

float prodScal(const Vecteur3d &v1,const Vecteur3d &v2) {
  return v1.x()*v2.x()+v1.y()*v2.y()+v1.z()*v2.z();
}

Vecteur3d scale(const Vecteur3d &v,float k) {
  Vecteur3d res=v;
  res.scale(k);
  return res;
}

Vecteur3d operator +(const Vecteur3d &v1,const Vecteur3d &v2) {
  Vecteur3d res;
  res.set(v1.x()+v2.x(),v1.y()+v2.y(),v1.z()+v2.z());
  return res;
}



/****************************************************************************/
/** classe Vertex
*/


void Vertex::init() {}

void Vertex::setNormal(float x,float y,float z) {
  n.set(x,y,z,false);
}

void Vertex::setPoint(float x,float y,float z) {
  p.set(x,y,z,false);
}

void Vertex::addNormal(const Vecteur3d &nf) {
  n=n+nf;
  nb_normal++;
}

void Vertex::addNormalBegin() {
  nb_normal=0;
}

void Vertex::addNormalEnd() {
  n.scale(1.0/static_cast<float>(nb_normal));
  if (n.norme()>0.0001)
    n.normaliser();
}