temp.c

#include <FPT.h>
#include <D3d_matrix.h>

double ambient; //amount of ambient light
double diffuse_max;
double halfangle = 40;
double radians = 3 * (M_PI / 180);
int hither = 10;
int LX, LY, LZ; //location of light source
int spec_power;
int WIDTH = 600; int HEIGHT = 600; int DEPTH = 600;


typedef struct {
  double centerx, centery, centerz;
  double x[10000], y[10000], z[10000];
  FILE *file;
  int numpolys; //the number of subobjects that make up the object
  int points; //number of points in whatever
  int shapeorder[1000][8]; //Where things connect to
  int shapes[10000]; //the shapes [which shape]
  int xcounter, ycounter, zcounter;
} Object;

typedef struct {
  double avg_depth;
  double color[3];
  double x[100];
  double y[100];
  double z[100];
  double x2d[100];
  double y2d[100];
  int size;
} Plane;

typedef struct {
  int counter;
  // Plane *plane;
  Plane plane[10000];
} Final_plane;

Final_plane total; //Global collection of planes

void printarray(double *a, int size) {
  int i;
  for (i = 0; i < size; i++) {
    printf("%.2lf\n", a[i]);
  }
  printf("\n");
}

//deletes an item from an array
int delete_from_parray(Plane *parray, int loc, int size) {
  int i;
  if (loc >= size + 1) {
    printf("Deletion not possible.\n");
    size = 0;
  } else {
    for (i = loc - 1 ; i < size - 1 ; i++) {
      parray[i] = parray[i + 1];
    }
  }
  return size - 1;
}

//reads in file
//Modified from lab2; does not read in colors
void readobject(FILE *g, Object* poly) {
  int j, k, p, np, shp[10000];
  // int temp_numpolys, temp_shapes[1000], temp_shapeorder[100][100];
  fscanf(g, "%d", &p);
  poly->points = p;
  // printf("there are %d points\n", poly->points);
  for (k = 0; k < poly->points; k++) {
    fscanf(g, "%lf  %lf  %lf", &poly->x[k], &poly->y[k],
           &poly->z[k]);
    // printf("(%lf,%lf,%lf)\n", poly->x[k], poly->y[k], poly->z[k]);
  }
  // printf("%d\n", sizeof(poly->x) / sizeof(poly->x[0]));
  fscanf(g, "%d", &np);
  poly->numpolys = np;
  // printf("there are %d objects in this whatever\n", poly->numpolys); //works up til here
  for (k = 0; k < np; k++) {
    fscanf(g, "%d", &shp[k]);
    poly->shapes[k] = shp[k];
    // printf("%d: ", poly->shapes[k]);
    for (j = 0; j < shp[k]; j++) {
      fscanf(g, "%d", &poly->shapeorder[k][j]);
      // printf("%d ", poly->shapeorder[k][j]);
    }
    // printf("\n");
  }
}

int Clip_Polygon_Against_Plane(
  double a, double b, double c, double d,
  double *polyx, double *polyy, double *polyz, int size,
  double *resx, double *resy, double *resz)

// Clip polygon against the plane ax + by + cz + d = 0,
// where ax + by + cz + d < 0 is considered IN.
// Incoming poly defined in arrays polyx, polyy, polyz with numverts = size.
// Clipped result values are stored in arrays resx, resy, resz
// The numverts of the clipped result is returned as value of the function.
{
  int num, i, j ;
  double x1, y1, z1,
         x2, y2, z2,
         x21, y21, z21,
         xintsct, yintsct, zintsct ;
  double den, t;
  double s1, s2 ;
  num = 0 ;
  for (i = 0 ; i < size ; i++) {
    j = (i + 1) % size ;

    // load up segment to be clipped
    x1 = polyx[i] ; y1 = polyy[i] ; z1 = polyz[i] ;
    x2 = polyx[j] ; y2 = polyy[j] ; z2 = polyz[j] ;

    s1 = (a * x1 + b * y1 + c * z1 + d) ;
    s2 = (a * x2 + b * y2 + c * z2 + d) ;
    // printf("s1:%.2lf,  s2:%.2lf,\n", s1, s2);

    if ((s1 >= 0) && (s2 >= 0)) {
      // out to out, do nothing
      // printf("out to out\n");
    } else if ((s1 < 0) && (s2 < 0)) {
      // in to in
      // printf("in to in\n");
      resx[num] = x2 ;
      resy[num] = y2 ;
      resz[num] = z2 ;
      num++ ;
    } else {
      // one is in, the other out, so find the intersection
      x21 = x2 - x1 ;
      y21 = y2 - y1 ;
      z21 = z2 - z1 ;
      den = a * x21 + b * y21 + c * z21;
      if (den == 0) continue ; // do nothing-should never happen
      t = -(a * x1 + b * y1 + c * z1 + d) / den ;
      xintsct = x1 + t * x21 ;
      yintsct = y1 + t * y21 ;
      zintsct = z1 + t * z21 ;

      if (s1 < 0) {
        // in to out
        // printf("in to out\n");
        resx[num] = xintsct ;
        resy[num] = yintsct ;
        resz[num] = zintsct ;
        num++ ;
      } else  {
        // out to in
        // printf("out to in\n");
        resx[num] = xintsct ;
        resy[num] = yintsct ;
        resz[num] = zintsct;
        num++ ;

        resx[num] = x2 ;
        resy[num] = y2 ;
        resz[num] = z2 ;
        num++ ;
      }
    }
  } // end for i
  return num ;  // return size of the result poly
}

//clips the face against the viewing pyramid
int clippers(double *x, double *y, double *z, int size) { //make temp
  double yonder = 100;
  double rads = halfangle * M_PI / 180;
  size = Clip_Polygon_Against_Plane(0, 1, tan(rads), 0, x, y, z, size, x, y, z);
  size = Clip_Polygon_Against_Plane(0, -1, tan(rads), 0, x, y, z, size, x, y, z);
  size = Clip_Polygon_Against_Plane(1, 0, tan(rads), 0, x, y, z, size, x, y, z);
  size = Clip_Polygon_Against_Plane(-1, 0, tan(rads), 0, x, y, z, size, x, y, z);
  size = Clip_Polygon_Against_Plane(0, 0, 1, -yonder, x, y, z, size, x, y, z);
  size = Clip_Polygon_Against_Plane(0, 0, 1, hither, x, y, z, size, x, y, z);

  return size;
}

//Compare method; auxillary for qsort
int compare (const void *p, const void *q) {
  Plane *a, *b ;

  a = (Plane*)p ; b = (Plane*)q ;

  return ((*a).avg_depth) < ((*b).avg_depth) ? 1 :
         ((*a).avg_depth) > ((*b).avg_depth) ? -1 : 0;
}

//converts vector to unit vector
void to_unit_vect(double *vect) {
  int i;
  double mag = sqrt(pow(vect[0], 2) + pow(vect[1], 2) + pow(vect[2], 2));
  for (i = 0; i < 3; i++) {
    // if (fabs(vect[i]) > 10e-7) {
    vect[i] /= mag;
    // }
  }
}

//returns the dot product of the n & l vectors
double vector_setup(double *x, double *y, double *z, double *n_vect,
                    double *l_vect, double *r_vect, double *e_vect)
{
  double vect1[3] = { x[0] - x[1], y[0] - y[1], z[0] - z[1] };
  double vect2[3] = { x[0] - x[2], y[0] - y[2], z[0] - z[2] };
  D3d_x_product(n_vect, vect1, vect2); //this creates the orthagonal vec
  to_unit_vect(n_vect);

  l_vect[0] = LX - x[0];
  l_vect[1] = LY - y[0];
  l_vect[2] = LZ - z[0];
  to_unit_vect(l_vect);

  e_vect[0] = 0 - x[0]; //Eye at 0,0,0
  e_vect[1] = 0 - y[0];
  e_vect[2] = 0 - z[0];
  to_unit_vect(e_vect);

  if (D3d_dot_product(l_vect, n_vect) < 0) {
    n_vect[0] *= -1;
    n_vect[1] *= -1;
    n_vect[2] *= -1;
  }

  double nl = D3d_dot_product(l_vect, n_vect);

  r_vect[0] = 2 * nl * n_vect[0] - l_vect[0];
  r_vect[1] = 2 * nl * n_vect[1] - l_vect[1];
  r_vect[2] = 2 * nl * n_vect[2] - l_vect[2];
  to_unit_vect(r_vect);

  return nl;
}

void color_setup(double intensity, double i_vect[3]) {
  double tippingpoint = ambient + diffuse_max;
  double temp1 = (intensity - tippingpoint) / (1 - tippingpoint);
  double temp2 = intensity / tippingpoint;
  int i;
  for (i = 0; i < 3; i++) {
    i_vect[i] = (intensity >= tippingpoint) ? temp1 * (1 - i_vect[i]) +
                i_vect[i] : temp2 * i_vect[i];
  }
}

void light_n_color(Plane* plane) {
  double n_vect[3] = {0.0};
  double l_vect[3] = {0.0};
  double e_vect[3] = {0.0};
  double r_vect[3] = {0.0};
  double i_vect[3] = {.9, 0, .2};
  double nl = vector_setup(plane->x, plane->y, plane->z,
                           n_vect, l_vect, r_vect, e_vect);
  double specular = 1 - ambient - diffuse_max;
  double er = D3d_dot_product(e_vect, r_vect);
  er = (er < 0) ? 0 : er;
  double intensity = (D3d_dot_product(e_vect, n_vect) < 0) ? ambient :
                     ambient + (diffuse_max * nl) + specular *
                     pow(er, spec_power);

  color_setup(intensity, i_vect);
  plane->color[0] = i_vect[0];
  plane->color[1] = i_vect[1];
  plane->color[2] = i_vect[2];
}

//converts the points from 3d to 2d
void to_3d(Plane* plane, double *tempx, double *tempy, double *tempz,
           int size)
{
  int j;
  double mod = (HEIGHT / 2) / tan(halfangle * (M_PI / 180));
  while (j < size) {
    if (fabs(tempz[j]) > 10e-7) {
      plane->x2d[j] = mod * tempx[j] / tempz[j] + (WIDTH / 2);
      plane->y2d[j] = mod * tempy[j] / tempz[j] + (WIDTH / 2);
      plane->x[j] = tempx[j];
      plane->y[j] = tempy[j];
      plane->z[j] = tempz[j];
      j++;
    } else {
      j++;
    }
  }
}

//puts all the planes into collection
void predraw(Object poly) {
  double tempx[100], tempy[100], tempz[100];
  int i, k, j; int minicounter = 0;
  Plane plane[poly.numpolys];
  for (k = 0; k < poly.numpolys; k++) {
    plane[k].avg_depth = 0.0;
    for (j = 0; j < poly.shapes[k]; j++) {
      tempx[j] = poly.x[poly.shapeorder[k][j]];
      tempy[j] = poly.y[poly.shapeorder[k][j]];
      tempz[j] = poly.z[poly.shapeorder[k][j]];
      plane[k].avg_depth += poly.z[poly.shapeorder[k][j]];
    }
    plane[k].size = clippers(tempx, tempy, tempz, j);
    if (plane[k].size >= 1) {
      to_3d(&plane[k], tempx, tempy, tempz, plane[k].size);
      light_n_color(&plane[k]);
      plane[k].avg_depth = plane[k].avg_depth / plane[k].size;
      minicounter++;
    }
  }
  // printf("mini: %d, hither:%d\n", minicounter,  hither);

  j = 0;
  for (k = 0; k < poly.numpolys; k++) {
    if (plane[k].size != 0) {
      total.plane[j + total.counter] = plane[k];
      j++;
    }
  }
  total.counter += minicounter;
}

//draws the all the planes based on average depth
void draw() {
  int i;
  qsort (total.plane, total.counter, sizeof(Plane), compare);
  printf("%d\n", total.counter);
  for (i = 0; i < total.counter; i++) {
    G_rgb(total.plane[i].color[0], total.plane[i].color[1],
          total.plane[i].color[2]);
    G_fill_polygon(total.plane[i].x2d, total.plane[i].y2d,
                   total.plane[i].size);
  }
}

//finds the largest/smallest value in array
int findextrema(double *y, int z, int swatch) {
  int position = 0; int i = 0;
  double temp = 0 + (swatch * HEIGHT);
  for (i = 0; i < z; i++) {
    if (swatch == 0 && y[i] > temp) { //finds largest
      position = i;
      temp = y[i];
    } else if (swatch == 1 && y[i] < temp) { //finds smallest
      position = i;
      temp = y[i];
    }
  }
  return position;
}

//finds the scale factor of the object
//also reveals the center of the object
double scale_n_fit(Object* poly) {
  int k;
  double smallx, bigx, smally, bigy, smallz, bigz;
  bigx = poly->x[findextrema(poly->x, poly->points, 0)];
  smallx = poly->x[findextrema(poly->x, poly->points, 1)];
  bigy = poly->y[findextrema(poly->y, poly->points, 0)];
  smally = poly->y[findextrema(poly->y, poly->points, 1)];
  bigz = poly->z[findextrema(poly->z, poly->points, 0)];
  smallz = poly->z[findextrema(poly->z, poly->points, 1)];

  double boxheight = bigy - smally;
  double boxwidth =  bigx - smallx;
  double boxdepth = bigz - smallz;

  poly->centerx = (bigx + smallx) / 2;
  poly->centery = (bigy + smally) / 2;
  poly->centerz = (bigz + smallz) / 2;
  double centers[3] = {poly->centerx, poly->centery,
                       poly->centerz
                      };
  return (findextrema(centers, 3, 1) == 1) ? WIDTH / boxwidth :
         (findextrema(centers, 3, 1) == 2) ? HEIGHT / boxheight :
         DEPTH / boxdepth;
}

//changes the message based on how many objects are inputted via command line
void welcome() {
  char q;
  printf("Please input the location of the light: ");
  scanf("%d %d %d", &LX, &LY, &LZ);
  printf("Please input the ambient light: ");
  scanf("%lf", &ambient);
  printf("Please input the diffuse max: ");
  scanf("%lf", &diffuse_max);
  printf("Please input the specularity exponent: ");
  scanf("%d", &spec_power);
  printf("\n");
}

void temp_welcome() {
  LX = 100; LY = 200; LZ = -50;
  ambient = .2;
  diffuse_max = .5;
  spec_power = 75;
}


int main (int argc, char **argv) {
  char q, action;
  double mat[4][4], minv[4][4], scaleFactor;
  int cc, sign, curObj, k, h;
  int increment = 20; int temp = 0;
  Object object[argc];

  for (cc = 1; cc < argc; cc++) {
    object[cc].file = fopen(argv[cc], "r"); //opens a file; r = read only
    if (object[cc].file == NULL) { //if the file is empty
      printf("can't open (1)\n");
      exit(1);
    } else {
      readobject(object[cc].file, &object[cc]);

      D3d_make_identity(mat); D3d_make_identity(minv);
      scaleFactor = scale_n_fit(&object[cc]);
      D3d_translate(mat, minv, -object[cc].centerx, -object[cc].centery,
                    -object[cc].centerz);
      D3d_scale(mat, minv, scaleFactor, scaleFactor, scaleFactor);
      D3d_mat_mult_points(object[cc].x, object[cc].y, object[cc].z,
                          mat, object[cc].x, object[cc].y,
                          object[cc].z, object[cc].points);
      temp += object[cc].numpolys;
    }
  }

  // total.plane = malloc(temp  * sizeof(Plane));
  // welcome();
  temp_welcome();
  curObj = 1;
  sign = 1 ;
  action = 't' ;


  if (curObj < argc && curObj > 0) {
    G_init_graphics(WIDTH, HEIGHT);
    object[curObj].xcounter = 0;
    object[curObj].ycounter = 0;
    object[curObj].zcounter = 0;

    while (1) {
      G_rgb(0, 0, 0);
      G_clear();
      total.counter = 0;

      for (cc = 1; cc < argc; cc++) {
        predraw(object[cc]);
      }
      draw();
      printf("z:%d, hither: %d\n", object[curObj].zcounter, hither);


      D3d_make_identity (mat) ;
      D3d_make_identity (minv) ;

      q = G_wait_key() ;

      if (q == 'q') {
        exit(0) ;
      } else if (q == 'c') {
        sign = -sign ;
      } else if (q == 't') {
        action = q ;
      } else if (q == 'S') {
        action = q ;
      } else if (q == 'r') {
        action = q ;
      } else if (q == 'h') {
        hither += 5 * sign;
      } else if (('0' <= q) && (q <= '9')) {
        k = q - '0' ;
        if (h != curObj) {
          curObj = k;
        }
      } else if ((q == 'x') && (action == 't')) {
        D3d_translate (mat, minv, sign * increment, 0, 0);
        object[curObj].xcounter = object[curObj].xcounter + (sign * increment);

      } else if ((q == 'y') && (action == 't')) {
        D3d_translate (mat, minv, 0, sign * increment, 0);
        object[curObj].ycounter = object[curObj].ycounter + (sign * increment);

      } else if ((q == 'z') && (action == 't')) {
        D3d_translate(mat, minv, 0, 0, sign * increment);
        object[curObj].zcounter = object[curObj].zcounter + (sign * increment);

      } else if ((q == 'x') && (action == 'r')) {
        D3d_translate(mat, minv, -object[curObj].xcounter, -object[curObj].ycounter, -object[curObj].zcounter);
        D3d_rotate_x(mat, minv, sign * radians);
        D3d_translate(mat, minv, object[curObj].xcounter, object[curObj].ycounter, object[curObj].zcounter);

      } else if ((q == 'y') && (action == 'r')) {
        D3d_translate(mat, minv, -object[curObj].xcounter, -object[curObj].ycounter, -object[curObj].zcounter);
        D3d_rotate_y(mat, minv, sign * radians);
        D3d_translate(mat, minv, object[curObj].xcounter, object[curObj].ycounter, object[curObj].zcounter);

      } else if ((q == 'z') && (action == 'r')) {
        D3d_translate(mat, minv, -object[curObj].xcounter, -object[curObj].ycounter, -object[curObj].zcounter);
        D3d_rotate_z(mat, minv, sign * radians);
        D3d_translate(mat, minv, object[curObj].xcounter, object[curObj].ycounter, object[curObj].zcounter);

      } else {
        printf("no action\n") ;
      }

      D3d_mat_mult_points(object[curObj].x, object[curObj].y,
                          object[curObj].z, mat,
                          object[curObj].x, object[curObj].y,
                          object[curObj].z,
                          object[curObj].points + 1) ;
      //the numpoints[curObj]+1 is because we have stored
      //the center of the object at the arrays' end
    }
  }
}