/* Remplissage 2D d'une facette triangulaire    */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Mars 2014                                    */

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

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

static int x1 = 9;
static int y1 = 3;
static int x2 = 30;
static int y2 = 20;
static int x3 = 5;
static int y3 = 29;

/* Variables et constantes globales             */

static const float blanc[]   = { 1.0F,1.0F,1.0F,1.0F };
static const float jaune[]   = { 1.0F,1.0F,0.0F,1.0F };
static const float magenta[] = { 1.0F,0.0F,1.0F,1.0F };
static const float rouge[]   = { 1.0F,0.0F,0.0F,1.0F };
static const float vert[]    = { 0.0F,0.7F,0.0F,1.0F };
static const float bleu[]    = { 0.0F,0.0F,1.0F,1.0F };

static int aff = 0;
static int t = 0;
static int s = 0;
static int nb = 0;

static void allumePixel(int x,int y) {
  glPointSize(9.0F);
  glBegin(GL_POINTS);
  glVertex2i(x*11+4,y*11+4);
  glEnd();
  glPointSize(1.0F);
}

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

/* Remplissage 2D d'un triangle                 */
/* Solution imparfaite car presentant           */
/* des problemes lors du collage                */
/* deux facettes adjacentes:                    */
/* Apparition possible de trous car des pixels  */
/* peuvent ne pas etre allumes a la limite      */
/* entre les deux facettes car allumes          */
/* pour aucune des deux facettes                */

static void bord(int xi,int yi,int xf,int yf,int *px) {
  int dx,dy,i,xinc,yinc,cumul,x,y;
  x = xi;
  y = yi;
  dx = xf - xi;
  dy = yf - yi;
  xinc = ( dx > 0 ) ? 1 : -1;
  yinc = ( dy > 0 ) ? 1 : -1;
  dx = abs(dx);
  dy = abs(dy);
  px[y] = x;
  if ( dx > dy ) {
    cumul = dx>>1;
    for ( i = 1 ; i <= dx ; i++ ) {
      x += xinc;
      cumul += dy;
      if ( cumul >= dx ) {
        cumul -= dx;
        y += yinc; }
      px[y] = x; } }
    else {
    cumul = dy>>1;
    for ( i = 1 ; i <= dy ; i++ ) {
      y += yinc;
      cumul += dx;
      if ( cumul >= dy ) {
        cumul -= dy;
        x += xinc; }
      px[y] = x; } }
}

static void remplissageTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
  int xd[4096];
  int xg[4096];
  if ( (x2-x1)*(y3-y1)-(x3-x1)*(y2-y1) > 0 ) {
    bord(x1,y1,x2,y2,xd);
    bord(x2,y2,x3,y3,xd);
    bord(x1,y1,x3,y3,xg); }
    else {
    bord(x1,y1,x2,y2,xg);
    bord(x2,y2,x3,y3,xg);
    bord(x1,y1,x3,y3,xd); }
  for ( int y = y1 ; y <= y3 ; y++ ) {
    for ( int x = xg[y] ; x <= xd[y] ; x++ ) {
      allumePixel(x,y); } }
} 

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

/* Scene dessinee                               */

static void traceBord(int xi,int yi,int xf,int yf) {
  glPointSize(9.0F);
  glBegin(GL_POINTS);
  int dx,dy,i,xinc,yinc,cumul,x,y;
  x = xi;
  y = yi;
  dx = xf - xi;
  dy = yf - yi;
  xinc = ( dx > 0 ) ? 1 : -1;
  yinc = ( dy > 0 ) ? 1 : -1;
  dx = abs(dx);
  dy = abs(dy);
  glVertex2i(x*11+4,y*11+4);
  if ( dx > dy ) {
    cumul = dx / 2;
    for ( i = 1 ; i <= dx ; i++ ) {
      x += xinc;
      cumul += dy;
      if ( cumul >= dx ) {
        cumul -= dx;
        y += yinc; }
      glVertex2i(x*11+4,y*11+4); } }
    else {
    cumul = dy / 2;
    for ( i = 1 ; i <= dy ; i++ ) {
      y += yinc;
      cumul += dx;
      if ( cumul >= dy ) {
        cumul -= dy;
        x += xinc; }
      glVertex2i(x*11+4,y*11+4); } }
  glEnd();
  glPointSize(1.0F);
}

static void outlineTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
  traceBord(x1,y1,x2,y2);
  traceBord(x1,y1,x3,y3);
  traceBord(x2,y2,x3,y3);
} 

static void scene1(void) {
  glPushMatrix();
  switch (aff) {
    case 0:
      glColor4fv(jaune);
      glBegin(GL_TRIANGLES);
      glVertex2d(x1*11+4,y1*11+4);
      glVertex2d(x2*11+4,y2*11+4);
      glVertex2d(x3*11+4,y3*11+4);
      glEnd();
      break;
    case 1:
      glColor4fv(jaune);
      glBegin(GL_TRIANGLES);
      glVertex2d(x1*11+4,y1*11+4);
      glVertex2d(x2*11+4,y2*11+4);
      glVertex2d(x3*11+4,y3*11+4);
      glEnd();
      glColor4fv(vert);
      outlineTriangle(x1,y1,x2,y2,x3,y3);
      break;
    case 2:
      glColor4fv(jaune);
      remplissageTriangle(x1,y1,x2,y2,x3,y3);
      break;
    case 3:
      glColor4fv(jaune);
      glBegin(GL_TRIANGLES);
      glVertex2d(x1*11+4,y1*11+4);
      glVertex2d(x2*11+4,y2*11+4);
      glVertex2d(x3*11+4,y3*11+4);
      glEnd();
      glColor4fv(vert);
      remplissageTriangle(x1,y1,x2,y2,x3,y3);
      break; }
  glPopMatrix();
}

static void fond(void) {
  glColor3fv(bleu);
  int tx = (glutGet(GLUT_WINDOW_WIDTH)+10)/11;
  int ty = (glutGet(GLUT_WINDOW_HEIGHT)+10)/11;
  for ( int x = 0 ; x <= tx ; x++ )
    for ( int y = 0 ; y <= ty ; y++ ) {
      glBegin(GL_LINE_LOOP);
      glVertex2i(x*11,y*11);
      glVertex2i(x*11+10,y*11);
      glVertex2i(x*11+10,y*11+10);
      glVertex2i(x*11,y*11+10);
      glEnd(); }
}

/* Fonction executee lors d'un rafraichissement */
/* de la fenetre de dessin                      */

static void display(void) {
  glClearColor(0.8F,0.8F,0.8F,1.0F);
  glClear(GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  fond();
  switch (s) {
    case 0 :
      scene1();
      break; }
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Erreur OpenGL: %d\n",error);
}

/* Fonction executee lors d'un changement       */
/* de la taille de la fenetre OpenGL            */
/* -> Ajustement de la camera de visualisation  */

static void reshape(int x,int y) {
  glViewport(0,0,x,y); 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0.0,x,0.0,y,-1000.0,1000.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

/* Fonction executee lors de la frappe          */
/* d'une touche du clavier                      */

static void keyboard(unsigned char key,int x,int y) {
  switch ( key ) {
    case 'n' :
      x1 = 9;
      y1 = 3;
      x2 = 30;
      y2 = 20;
      x3 = 5;
      y3 = 29;
      glutPostRedisplay();
      break;
/*    case 'm' :
      delete(p1);
      delete(p2);
      delete(p3);
      p1 = new Position3D(2+rand()%28,2+rand()%28,0.0);
      p2 = new Position3D(2+rand()%28,2+rand()%28,0.0);
      p3 = new Position3D(2+rand()%28,2+rand()%28,0.0);
      glutPostRedisplay();
      break;*/
    case 's' :
      s = (s+1)%2;
      glutPostRedisplay(); 
      break;
    case 0x0D :
      t = (t+1)%3;
      glutPostRedisplay(); 
      break;
    case 0x20 :
      aff = (aff+1)%4;
      glutPostRedisplay(); 
      break;
    case 0x1B :
      exit(0); 
      break; }
}

/* Fonction principale                          */

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE);
  glutInitWindowSize(350,350); 
  glutInitWindowPosition(50,50); 
  glutCreateWindow("Remplissage 2D triangle"); 
  glutKeyboardFunc(keyboard);
  glutReshapeFunc(reshape);
  glutDisplayFunc(display);
  glutMainLoop();
  return(0);
}