/* File: simple_xyzc.c
   Reads two files:
       color_map file
           r[0] g[0] b[0]       red, green, blue color map entries (float, float, float)
	   ...
       model file
           nv nt                number of vertices, number of triangles (int, int)
	   x[0] y[0] z[0] c[0]  x, y, z, color_index (float, float, float, int)
	   ...
	   x[nv-1] y[nv-1] z[nv-1] c[nv-1]      ""
	   t[0] t[1] t[2]       first triangle verts 0, 1, 2 (int)
	   ...
	   t[3*(nt-1)] t[3*(nt-1)+1] t[3*(nt-1)+2]    last tri verts 0, 1, 2
    Displays the set of triangles.
    This program uses a number of standard C paradigms for accessing data, to
        show thier use.  Typically one would use a less disparate set of methods,
	for consistency.
*/

#include <stdio.h>
#include <GL/glut.h>

#define MAXNCOLOR 1024
static int ncolor;
static int color[MAXNCOLOR][3];
static int nvert;
static float *x, *y, *z;
static int *cind;
static int ntri;
static int *tri;

#define GETMINMAX(MN, MX, V) { \
    if ((V) < (MN)) (MN) = (V); \
    if ((V) > (MX)) (MX) = (V); \
}

void readCmap(char *fname)
{
    int i;
    FILE *fpin;
    if (!(fpin = fopen(fname, "r"))) {
        fprintf(stderr, "readCmap could not open %s\n", fname);
	fflush(stderr);
	exit(1);
    }
    ncolor = 0;
    do {
        if (fscanf(fpin, "%d %d %d", &color[ncolor][0],
	           &color[ncolor][1], &color[ncolor][2]) == 3)
            ncolor++;
    } while (!feof(fpin));
for (i=0; i<ncolor; i++)
printf("color[%4d] = %4d %4d %4d\n", i,
color[i][0], color[i][1], color[i][2]);
fflush(stdout);
    fclose(fpin);
}

void readData(char *fname)
{
    FILE *fpin;
    float *px, *py, *pz;
    int *pcind, *ptri;
    int ivert, itri;
    if (!(fpin = fopen(fname, "r"))) {
        fprintf(stderr, "readData could not open %s\n", fname);
	fflush(stderr);
	exit(1);
    }
    fscanf(fpin, "%d %d", &nvert, &ntri);
    printf("nvert, ntri = %d %d\n", nvert, ntri);
    x = (float *)malloc(sizeof(float)*nvert);
    y = (float *)malloc(sizeof(float)*nvert);
    z = (float *)malloc(sizeof(float)*nvert);
    cind = (int *)malloc(sizeof(int)*nvert);
    tri = (int *)malloc(sizeof(int)*3*ntri);
    px = x;
    py = y;
    pz = z;
    pcind = cind;
    for (ivert=0, px=x, py=y, pz=z, pcind = cind;
         ivert<nvert;
	 ivert++, px++, py++, pz++, pcind++)
        fscanf(fpin, "%f %f %f %d", px, py, pz, pcind);
    ptri = tri;
    for (itri=0; itri<ntri; itri++, ptri+=3)
        fscanf(fpin, "%d %d %d", ptri, ptri+1, ptri+2);
    fclose(fpin);
}

void boundsData(float *xmin, float *xmax, float *ymin, float *ymax,
                float *zmin, float *zmax)
{
    int ivert;
    if (nvert > 0) {
	*xmin = x[0]; *xmax = x[0];
	*ymin = y[0]; *ymax = y[0];
	*zmin = z[0]; *zmax = z[0];
    }
    for (ivert=0; ivert<nvert; ivert++) {
	GETMINMAX(*xmin, *xmax, x[ivert])
	GETMINMAX(*ymin, *ymax, y[ivert])
	GETMINMAX(*zmin, *zmax, z[ivert])
    }
}

makeNormal(int ivert0, int ivert1, int ivert2, float *vn)
{
    float x1, y1, z1;
    float x2, y2, z2;
    x1 = x[ivert1] - x[ivert0];
    y1 = y[ivert1] - y[ivert0];
    z1 = z[ivert1] - z[ivert0];
    x2 = x[ivert2] - x[ivert0];
    y2 = y[ivert2] - y[ivert0];
    z2 = z[ivert2] - z[ivert0];
    vn[0] = y1*z2 - y2*z1;
    vn[1] = x2*z1 - x1*z2;
    vn[2] = x1*y2 - x2*y1;
}

void display(void)
{
    int i, itri, ivert, color_index;
    int *ptri;
    float vn[3];
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    ptri = tri;
    glBegin(GL_TRIANGLES);
    for (itri=0; itri<ntri; itri++, ptri+=3) {
	makeNormal(ptri[0], ptri[1], ptri[2], vn);
	glNormal3fv(vn);
	for (i=0; i<3; i++) {
	    ivert = ptri[i];
	    color_index = cind[ivert];
	    glColor3ub((GLubyte)color[color_index][0],
	               (GLubyte)color[color_index][1], 
		       (GLubyte)color[color_index][2]);
	    glVertex3f(x[ivert], y[ivert], z[ivert]);
	}
    }
    glEnd();
    glutSwapBuffers();
}

void init(void)
{
    float fov, asp, near, far;
    float xeye, yeye, zeye;
    float xstare, ystare, zstare;
    float xup, yup, zup;
    float xsize, ysize, zsize;
    float xmin, ymin, zmin;
    float xmax, ymax, zmax;
    GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0};
    GLfloat light_ambient[] = {0.2, 0.2, 0.2, 1.0};
    GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat light_specular[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat light_position[] = {1.0, -1.0, 1.0, 0.0};
    GLfloat mat_ambient[] = {0.8, 0.1, 0.5, 1.0};
    GLfloat mat_diffuse[] = {0.8, 0.1, 0.5, 1.0};

    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);

    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);

    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glShadeModel(GL_FLAT);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_AUTO_NORMAL);

    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    
    glEnable(GL_DEPTH_TEST);
    glClearDepth(1.0);
    glClearColor(0.3, 0.3, 0.3, 0.0);

    boundsData(&xmin, &xmax, &ymin, &ymax, &zmin, &zmax); 
    xsize = xmax - xmin;
    ysize = ymax - ymin;
    zsize = zmax - zmin;
    xstare = (xmin+xmax)/2.0;
    ystare = (ymin+ymax)/2.0;
    zstare = (zmin+zmax)/2.0;
    xeye =   xstare + xsize/2.0;
    yeye =   ystare - 2*ysize;
    zeye =   zstare + zsize/4.0;
    xup = 0.0;
    yup = 0.0;
    zup = 1.0;
    fov = 40.0;
    asp = 1.00;
    near =  0.01*(xsize+ysize+zsize);
    far =   10.0*(xsize+ysize+zsize);

    printf("xmin, xmax = %13.6f %13.6f\n", xmin, xmax);
    printf("ymin, ymax = %13.6f %13.6f\n", ymin, ymax);
    printf("zmin, zmax = %13.6f %13.6f\n", zmin, zmax);
    printf("size   = %12.5f %12.5f %12.5f\n", xsize, ysize, zsize);
    printf("veye   = %12.5f %12.5f %12.5f\n", xeye, yeye, zeye);
    printf("vstare = %12.5f %12.5f %12.5f\n", xstare, ystare, zstare);
    printf("vup    = %12.5f %12.5f %12.5f\n", xup, yup, zup);
    printf("near, far    = %12.5f %12.5f\n", near, far);
    fflush(stdout);

    glMatrixMode(GL_PROJECTION);
    gluPerspective( fov, asp, near, far);

    glMatrixMode(GL_MODELVIEW);
    gluLookAt(xeye, yeye, zeye, xstare, ystare, zstare, xup, yup, zup);
}

void usage()
{
    fprintf(stderr, "ex_color_vert fname_colormap fname_data\n");
    fflush(stderr);
    exit(1);
}

int main(int argc, char **argv)
{
  if (argc != 3)
      usage();

  readCmap(argv[1]);
  readData(argv[2]);
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutCreateWindow("simple_xyzc");
  glutDisplayFunc(display);
  init();
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}