// 1*1 unit square drawn with triangle_strips. Normal points in pos.
// y direction.  Allows for lighting effects with textures.
void twDrawUnitSquare(float w, float h) {
    int i,j;
    GLfloat dw = 1.0/w;
    GLfloat dh = 1.0/h;
    glNormal3f(0,1,0);
    for( i=0; i<w; ++i) {
        glBegin(GL_TRIANGLE_STRIP);
        for( j=0; j<=h; ++j ) {
            if (j%2) glTexCoord2f(1,0); else glTexCoord2f(0,0);
            glVertex3f(dw*i,0,dh*j);
            if (j%2) glTexCoord2f(1,1); else glTexCoord2f(0,1);
            glVertex3f(dw*(i+1),0,dh*j);
        }
        glEnd();
    }
}

// ======================================================================
// US Flag texture.  It's computed and sent down the graphics pipeline
// when you call twUSflag().  If you're planning to do this more than
// once, it's more efficient to use texture binding.

const int USflagWidth  = 256;
const int USflagHeight = 128;

// We use RGBA to avoid alignment issues.  That is, this is an array of
// four-byte values, where each bytes is a color dimension: red, green,
// blue and alpha.  Because they are all four bytes, we don't have to
// worry about how C aligns these things in memory.

GLubyte USflagArray[USflagHeight][USflagWidth][4];

void setRGB(int row, int col, GLubyte RR, GLubyte GG, GLubyte BB) {
    USflagArray[row][col][0] = RR;
    USflagArray[row][col][1] = GG;
    USflagArray[row][col][2] = BB;
    USflagArray[row][col][3] = 255;
}

enum { RED, WHITE, BLUE };

void setColor(int row, int col, int colorcode) {
    USflagArray[row][col][0] = colorcode != BLUE ? 0xFF : 0;
    USflagArray[row][col][1] = colorcode == WHITE? 0xFF : 0;
    USflagArray[row][col][2] = colorcode != RED  ? 0xFF : 0;
    USflagArray[row][col][3] = 255;
}

void setStar(int row, int col) {
    /* Each star is in a 5x5 box.  With no anti-aliasing, pixels are
       either white or blue. */
    int i;
    setColor(row,col+2,WHITE); setColor(row,col+2,WHITE);
    ++row;
    for(i=0;i<5;i++) setColor(row,col+i,WHITE);
    ++row;
    for(i=1;i<4;i++) setColor(row,col+i,WHITE);
    ++row;
    for(i=0;i<5;i++)
        if(i!=2) setColor(row,col+i,WHITE);
}

void twUSflag() {
    int stripe_height=8;        // each stripe is 8 pixels high
    int height=stripe_height*13; // the flag is 13 stripes high
    int width=(int) (height*1.9); // the flag's aspect ratio is 1.9
    int union_height=7*stripe_height; // the union is 7 stripes high
    int union_width=(int) (union_height*(0.76/(7.0/13.0)));
    int star_size = 5;          // each star's size, in pixels
    int i, j;
    int row, col;
    // Initialize everything to a gray background
    for(row=0; row<USflagHeight; ++row)
        for(col=0; col<USflagWidth; ++col)
            setRGB(row,col,0x80,0x80,0x80);
    // 7 red stripes, 
    for(i=0; i<7; ++i)
        for(row=i*2*stripe_height; row<(i*2+1)*stripe_height; ++row)
            for(col=0; col<width; ++col)
                setColor(row,col,RED);
    // 6 white stripes, 
    for(i=0; i<6; ++i)
        for(row=(i*2+1)*stripe_height; row<(i+1)*2*stripe_height; ++row)
            for(col=0; col<width; ++col)
                setColor(row,col,WHITE);
    // Fill in the union with blue.
    for(row=0; row<union_height; ++row)
        for(col=0; col<union_width; ++col)
            setColor(row,col,BLUE);
    // 5 rows of 6 stars.  There's one blue border row and col,
    // one row between star rows and one col between star cols
    for(i=0; i<5; ++i )
        for(j=0; j<6; ++j )
            setStar(i*2*(star_size+1)+1,j*2*(star_size+2)+1);
    // 4 rows of 5 stars
    for(i=0; i<4; ++i )
        for(j=0; j<5; ++j ) 
            setStar((i*2+1)*(star_size+1)+1,(j*2+1)*(star_size+2)+1);
    // Finally done computing the flag array.  Now time to send it down
    // the graphics pipeline.  
    glTexImage2D(GL_TEXTURE_2D, 0, 3, USflagWidth, USflagHeight, 0,
                 GL_RGBA, GL_UNSIGNED_BYTE, USflagArray);
}

// ======================================================================

// Returns true if the integer is a power of two between 2^0 and 2^16, inclusive.
bool pow2(int x) {
    return
        x == 1 || x==2 || x==4 || x==8 || x==16 ||
        x==32 || x==64 || x==128 || x==256 ||
        x== 512 || x==1024 || x==2048 || x==4096 ||
        x==8192 || x==16384 || x==32768 || x==65536;
}

/* Adapted from code from
   http://www.ugrad.cs.ubc.ca/spider/cs414/sep2002_assmt/a3.html.

   The API here is that the twTex2D function substitutes for the glTex2D
   function.  File type ppm. You have to do everything else.

   This does not handle all PPM files; see "man ppm" for the exact file
   format.  We should be using netpbm; see below.
*/

void twTex2D(char *filename, bool verbose) {
  FILE *fp; 
  int width, height, maxval, size, count, return_value;
  unsigned char c1, c2;
  unsigned char* data;

  if(verbose) printf("loading texture from %s using obsolete function twTex2D\n",filename);
  fp = fopen(filename,"r");
  if(!fp) {
      printf("Unable to open %s\n",filename);
      return;
  }
  fscanf(fp,"%c%c",&c1, &c2);
  if (c1!='P' || c2!='6') {
      printf("Wrong file format for %s:  magic bytes are %c %c.\n",
             filename,c1,c2);
      return;
  }
  fscanf(fp," %d %d %d",&width, &height, &maxval);
  if(verbose) printf("%s: %d x %d image\n",filename,width,height);
  if(!pow2(width)) {
      printf("Error for %s: width is not a power of two:  %d\n",filename,width);
      return;
  }
  if(!pow2(height)) {
      printf("Error for %s: height is not a power of two:  %d\n",filename,height);
      return;
  }
  fgetc(fp);           // discard white-space character
  size = width*height*3;
  data = (unsigned char *) malloc(size);
  count=0;
  return_value = fread(data, 1, size, fp);
  // printf("first pixel = %d %d %d\n", data[0], data[1], data[2]);
  fclose(fp);
  //glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE,
        data);
  free(data);
}

/* All the PPM stuff is excluded from the computation (making the next
   two functions empty) if this symbol is not defined.  This allows
   most things to compile and run on a system without the netpbm
   library.  Netpbm is available for Linux and Mac OS X; I dunno
   about Windows, yet. */

#ifdef NETPBM
extern "C" {
#include <ppm.h>
}
#endif

int twPPM_Tex2D(char *filename, bool verbose) {
#ifdef NETPBM
  FILE *fp; 
  int rows, cols;
  pixval maxPixValue;                // this is just an unsigned int

  filename = twPathname(filename,verbose);
  if(NULL==filename) return 1;
  if(verbose)
      fprintf(stderr,"Opening texture file %s.\n",filename,strlen(filename));
  fp = fopen(filename,"r");
  if(!fp) {
      fprintf(stderr,"Unable to open %s\n",filename);
      perror("in twPPM_Tex2d");
      return 1;
  }
  /* The format of the image is as an array of rows (so that the caller
     doesn't have to do the row-major-order stuff by hand), where each row
     is an array of pixel structures (see /usr/include/ppm.h) and the
     elements of the pixel structure are an unsigned int, so the
     sizeof(pixel) is 12.  We use the accessor macros to hide this, of
     course, but it's important to know that we can't just cast this value
     to the kind of 2D array that OpenGL wants.  */
  pixel** image = ppm_readppm( fp, &cols, &rows, &maxPixValue);
  int rv=fclose(fp);
  if(rv != 0) {
      fprintf(stderr,"Error closing %s: %d\n",filename,errno);
  }
  if(!pow2(cols)) {
      fprintf(stderr,"%s: cols (%d) is not a power of two.\n",filename,cols);
      return 2;
  }
  if(!pow2(rows)) {
      fprintf(stderr,"%s: rows (%d) is not a power of two.\n",filename,rows);
      return 3;
  }
  if(verbose)
      printf("%s: %d x %d x %d image\n",filename,cols,rows,maxPixValue);
  /* This is the kind of array that OpenGL wants.  We take advantage of
     the C++ ability to declare an array using dimensions that are
     run-time values. */
  GLubyte texture[rows][cols][3];
  texture[rows-1][cols-1][0] = 255;
  for(int i=0;i<rows;i++) 
      for(int j=0;j<cols;j++) {
          pixel* p = &image[i][j];
          // printf("%d %d (%x,%x,%x)\n",i,j,PPM_GETR(*p),PPM_GETG(*p),PPM_GETB(*p));
          texture[i][j][0] = PPM_GETR(*p);
          texture[i][j][1] = PPM_GETG(*p);
          texture[i][j][2] = PPM_GETB(*p);
      }
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  twError();
  // Notice that we don't have to do any coercion for the array type.
  glTexImage2D(GL_TEXTURE_2D, 0, 3, cols, rows, 0, GL_RGB, GL_UNSIGNED_BYTE,
               texture);
  twError();
  ppm_freearray(image,rows);
#endif
}

/* Returns the smallest power of two that is not less than the argument;
   in other words, it rounds this up to the next power of two. */

int ceil2(int x) {
    int y = 1;
    for(;;) {
        if(y>=x) return y;
        y = y << 1;
    }
}

/* returns zero if success, and 1 if failure (unable to open file). */

int twPPM_Tex2D(char *filename, bool verbose, GLfloat& width, GLfloat& height) {
#ifdef NETPBM
  FILE *fp; 
  int cols, rows, fmt;
  pixval maxPixValue;                // this is just an unsigned int, typically 255
  int rows2, cols2;                // the rows and cols rounded up to a power of 2

  filename = twPathname(filename,verbose);
  if(NULL==filename) return 1;
  if(verbose)
      fprintf(stderr,"Opening texture file %s.\n",filename,strlen(filename));
  fp = fopen(filename,"r");
  if(!fp) {
      fprintf(stderr,"Unable to open %s\n",filename);
      perror("in twPPM_Tex2D");
      return 1;
  }
  ppm_readppminit( fp, &cols, &rows, &maxPixValue, &fmt);
  cols2 = ceil2(cols);
  rows2 = ceil2(rows);
  width = ((GLfloat) cols)/((GLfloat) cols2);
  height = ((GLfloat) rows)/((GLfloat) rows2);
  if(verbose) printf("%s: %d x %d x %d image rounded up to %d x %d (%f,%f)\n",
                     filename,cols,rows,maxPixValue,cols2,rows2,width,height);
  pixel* imagerow = ppm_allocrow( cols );
  GLubyte texture[rows2][cols2][3]; 
  for(int i=0; i<rows;i++) {
      ppm_readppmrow( fp, imagerow, cols, maxPixValue, fmt );
      // copy the image data
      for(int j=0; j<cols; j++) {
          pixel* p = &imagerow[j];
          texture[i][j][0] = PPM_GETR(*p);
          texture[i][j][1] = PPM_GETG(*p);
          texture[i][j][2] = PPM_GETB(*p);
      }
      // fill the rest of the row with 50% gray
      for(int j=cols; j<cols2; j++) {
          texture[i][j][0] = 
              texture[i][j][1] = 
              texture[i][j][2] = 128;
      }
  }
  // fill the rest of the array with 50% gray
  for(int i=rows; i<rows2; i++)
      for(int j=0; j<cols2; j++)
          texture[i][j][0] = 
              texture[i][j][1] = 
              texture[i][j][2] = 128;
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  twError();
  glTexImage2D(GL_TEXTURE_2D, 0, 3, cols2, rows2, 0, GL_RGB, GL_UNSIGNED_BYTE,
               texture);
  twError();
  ppm_freerow(imagerow);
#endif
  return 0;
}


/* Asks user to specify the filename and assigns it to a given textureNumber */
int twLoadTexture(int textureNumber, char* filename) {
  glBindTexture(GL_TEXTURE_2D, textureNumber);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  return twPPM_Tex2D(filename, 0);
}