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

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

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include "Polygone3D.h"
#include "Position3D.h"
#include "Direction3D.h"

/* Constructeurs                                */

Polygone3D::Polygone3D(void) {
  t = NULL;
  l = 0;
  n = 0;
}

Polygone3D::Polygone3D(int l) {
  init(l);
}

Polygone3D::Polygone3D(Polygone3D *lp) {
  t = ( lp->n > 0 ) ? (Position3D **) calloc(lp->n,sizeof(Position3D *)) : NULL;
  n = 0;
  l = lp->n;
  for ( int i = 0 ; i < n ; i++ )
    add(lp->t[i]);
}

/* Destructeur                                  */

Polygone3D::~Polygone3D(void) {
  for ( int i = 0 ; i < l ; i++ ) {
    if ( t[i] ) {
      delete(t[i]); } }
  delete(t);
}

/* Allocation pour np Position3D disponibles    */

void Polygone3D::init(int np) {
  t = ( np > 0 ) ? (Position3D **) calloc(np,sizeof(Position3D *)) : NULL;
  l = np;
  n = np;
  for ( int i = 0 ; i < np ; i++ )
    t[i] = new Position3D();
}

/* Ajout d'une Position3D                       */

void Polygone3D::add(Position3D *p) {
  if ( l == 0 ) {
    t =(Position3D **) calloc(1,sizeof(Position3D *));
    l = 1; }
    else
    if ( n == l ) {
      t =(Position3D **) realloc(t,(l+1)*sizeof(Position3D *));
      l++; }
  t[n] = new Position3D(p);
  n++;
}

/* Dessin OpenGL                                */

void Polygone3D::draw(void) {
  glBegin(GL_POLYGON);
  for ( int i = 0 ; i < n ; i++ ) {
    glVertex3dv(t[i]->c); }
  glEnd();
}

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

/* Test de planarite                            */

const double EPSILON = 0.000001;

static int vecteurNul(Direction3D *d) {
  return( (abs(d->c[0]) < EPSILON ) &&
          (abs(d->c[1]) < EPSILON ) &&
          (abs(d->c[2]) < EPSILON ) );
}

int Polygone3D::testPlanarite(void) {
  Direction3D *d12;
  int p = 0;
  do {
    d12 = new Direction3D(t[p],t[(p+1)%n]);
    Direction3D *d13 = new Direction3D(t[p],t[(p+2)%n]);
    d12->produitVectoriel(d13);
    delete(d13); }
  while ( vecteurNul(d12) );
  for ( int i = 3 ; i < n ; i++ ) {
    Direction3D *d = new Direction3D(t[p],t[(p+i)%n]);
    double ps = d->produitScalaire(d12);
    delete(d);
    if ( abs(ps) > EPSILON ) {
      delete(d12);
      return(0); } }
  delete(d12);
  return(1);
}

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