import java.awt.*;

/**
    Program:  LitSurf19
    Purpose:  
    @author:  Paul Garrett, garrett@math.umn.edu
    @version: 19, Tue Feb 18 15:35:14 CST 1997
*/

public class LitSurf19 extends java.applet.Applet {

  final int xMax = 80;
  final int yMax = 40;

  float[] uPov, iPov, jPov; // coords in which to view

  int theHeight, theWidth;

  /* z-axis up, y-axis to right, x-axis 'out of board': this
     respects the right-hand rule... */

  final double div = (double) .04;
  final float cos = (float) Math.cos(Math.PI * div);
  final float sin = (float) Math.sin(Math.PI * div);
  final float[][] uRotMx = {{1F,0F,0F}, {0F,cos,-sin}, {0F,sin,cos}};
  final float[][] iRotMx = {{cos,0F,-sin}, {0F,1F,0F}, {sin,0F,cos}};
  final float[][] jRotMx = {{cos,-sin,0F}, {sin,cos,0F}, {0F,0F,1F}};

  float[][] theSurface; // 3D graph in native numbers z = f(x,y)

  final float xScale = 10F;
  final float yScale = 10F;
  final float zScale = 80F;
  int[][][] theProjection; // 2D projection, depending upon Light and POV
  float[] theLight; // (unit?) vector direction of light

  Color[] theColors; // depending on at least lighting...
  int[][][] theLighting; // for 2 triangles
  boolean[][][] queryVisible; // query visible from POV?

  final float theFunction(int firstIn, int secondIn) {
    return (float) (Math.sin(Math.PI * ((float) firstIn) / 20F) *
		   Math.sin(Math.PI * ((float) secondIn) / 20F)) ;
  }

  final void computeQueryVisible() {
    queryVisible = new boolean[xMax+1][yMax+1][2];
    float[] avector = new float[3];
    float[] another = new float[3];
    avector[0] = xScale;
    avector[1] = 0F;
    another[0] = 0F;
    another[1] = yScale;
    float[] crossp = new float[3];
    for (int i=0; i<xMax; i++) {
      for (int j=0; j<yMax; j++) {
	avector[2] = zScale * (theSurface[i+1][j] - theSurface[i][j]);
	another[2] =  zScale * (theSurface[i][j+1] - theSurface[i][j]);
	if (dotProduct(uPov, crossProduct(avector,another)) > 0) {
	  queryVisible[i][j][0] = true;
	}
	else {
	  queryVisible[i][j][0] = false;
	}

	avector[2] = zScale * (theSurface[i+1][j+1] - theSurface[i][j+1]);
	another[2] = zScale * (theSurface[i+1][j+1] - theSurface[i+1][j]);
	if (dotProduct(uPov, crossProduct(avector,another)) > 0) {
	  queryVisible[i][j][1] = true;
	}
	else {
	  queryVisible[i][j][1] = false;
	}
      }
    }
  }


  /* The following method computes the two components of
   * theLighting array to be the dot product of theLight vector with a normal vector
   * to the 'forward' resp. 'backward' triangle with flip-flop vertex there
   * See the formula below
   */

  final void computeLighting() {
    theLighting = new int[xMax+1][yMax+1][2];
    float[] avector = new float[3];
    float[] another = new float[3];
    avector[0] = xScale;
    avector[1] = 0F;
    another[0] = 0F;
    another[1] = yScale;
    float[] crossp = new float[3];
    float len;
    for (int i=0; i<xMax; i++) {
      for (int j=0; j<yMax; j++) {
	avector[2] = zScale * (theSurface[i+1][j] - theSurface[i][j]);
	another[2] = zScale * (theSurface[i][j+1] - theSurface[i][j]);
	crossp = crossProduct(avector,another);
	len = (float) Math.sqrt(dotProduct(crossp,crossp));
	theLighting[i][j][0] = 
	  (int) (100F * dotProduct(theLight, crossp)/len);

	avector[2] = zScale * (theSurface[i+1][j+1] - theSurface[i][j+1]);
	another[2] = zScale * (theSurface[i+1][j+1] - theSurface[i+1][j]);
	crossp = crossProduct(avector,another);
	len = (float) Math.sqrt(dotProduct(crossp,crossp));
	theLighting[i][j][1] = 
	  (int) (100F * dotProduct(theLight, crossp) / len);
      }
    }
  }

  final void initColors() {
    // First, do grey-tone 
    theColors = new Color[101];
    for (int i=0; i<=100; i++) {
      theColors[i] = new Color(Color.HSBtoRGB(.97F,.97F,((float) i)/102F));
    }
  }

  /* *************************** */

  final void computeTheProjection() { // and lighting...
    theProjection = new int[xMax+1][yMax+1][2];
    for (int i=0; i<=xMax; i++) {
      for (int j=0; j<=yMax; j++) {
	theProjection[i][j][0] = theWidth/4 + 
	  (int) ( ((float) i) * xScale * iPov[0] +
	  ((float) j) * yScale * iPov[1] + theSurface[i][j] * zScale * iPov[2]);
	theProjection[i][j][1] = theHeight/10 - 
	  (int) ( ((float) i) * xScale * jPov[0] +
	  ((float) j) * yScale * jPov[1] + theSurface[i][j] * zScale * jPov[2]);
      }
    }
  }


  public void init() {
    theHeight = this.size().height;
    theWidth = this.size().width;
    initColors();
    computeSurface();
    initPOV();
    computeQueryVisible();
    computeLighting();
    computeTheProjection();
    //    repaint();    
  }

  final void computeSurface() {
    theSurface = new float[xMax-0+1][yMax-0 + 1];
    for (int i=0; i<=xMax; i++) {
      for (int j=0; j<=yMax; j++) {
	theSurface[i][j] = theFunction(i,j);
      }
    }
  }

  public void paint(Graphics g) { // NB for back-to-front:
    // y-axis is usual x-axis, x-axis is "out-of-plane", z-axis vertical, etc.
    int[] xs = new int[4];
    int[] ys = new int[4];
    
    for (int i=0; i<xMax; i++) {     
      for (int j=0; j<yMax; j++) {
	xs[0] = theProjection[i][j][0];
	ys[0] = theProjection[i][j][1];
	xs[1] = theProjection[i+1][j][0];
	ys[1] = theProjection[i+1][j][1];
	xs[2] = theProjection[i][j+1][0];
	ys[2] = theProjection[i][j+1][1];
	xs[3] = theProjection[i][j][0];
	ys[3] = theProjection[i][j][1];
	  
	if (queryVisible[i][j][0]) {
	  g.setColor(theColors[theLighting[i][j][0]]);
	}
	else {
	  g.setColor(Color.gray);
	}
	g.fillPolygon(new Polygon(xs,ys,4));
	//	g.setColor(Color.darkGray);
	//	g.drawPolygon(new Polygon(xs,ys,4));
	
	xs[0] = theProjection[i+1][j+1][0];
	ys[0] = theProjection[i+1][j+1][1];
	xs[3] = theProjection[i+1][j+1][0];
	ys[3] = theProjection[i+1][j+1][1];
	
	if (queryVisible[i][j][1]) {
	  g.setColor(theColors[theLighting[i][j][1]]);
	}
	else {
	  g.setColor(Color.gray);
	}
	g.fillPolygon(new Polygon(xs,ys,4));
	//	g.setColor(Color.darkGray);
	//	g.drawPolygon(new Polygon(xs,ys,4));
      }
    }
  }

final float[] crossProduct(float[] x, float[] y) {
    float[] out = new float[3];
    out[0] = x[1] * y[2] - x[2] * y[1];
    out[1] = x[2] * y[0] - x[0] * y[2];
    out[2] = x[0] * y[1] - x[1] * y[0];
    return out;
  }

 final float[] subtractVector(float[] x, float[] y) {
    float[] out = new float[3];
    out[0] = x[0] - y[0];
    out[1] = x[1] - y[1];
    out[2] = x[2] - y[2];
    return out;
  }

  final float dotProduct(float[] x, float[] y) {
    float out = x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
    return out;
  }

  final float[] linearTransform(float[][] M, float[] v) {
    float[] out = new float[3];
    out[0] = M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2];
    out[1] = M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2];
    out[2] = M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2];
    return out;
  }

  final void uRot() {
    uPov = linearTransform(uRotMx, uPov);
    iPov = linearTransform(uRotMx, iPov);
    jPov = linearTransform(uRotMx, jPov);
  }

  final void iRot() {
    uPov = linearTransform(iRotMx, uPov);
    iPov = linearTransform(iRotMx, iPov);
    jPov = linearTransform(iRotMx, jPov);
  }

  final void jRot() {
    uPov = linearTransform(jRotMx, uPov);
    iPov = linearTransform(jRotMx, iPov);
    jPov = linearTransform(jRotMx, jPov);
  }

  final void initPOV() {
    uPov = new float[3];
    iPov = new float[3];
    jPov = new float[3];

    uPov[0] = 1F;
    uPov[1] = 0F;
    uPov[2] = 0F;

    iPov[0] = 0F;
    iPov[1] = 1F;
    iPov[2] = 0F;

    jPov[0] = 0F;
    jPov[1] = 0F;
    jPov[2] = 1F;

    iRot();
    iRot();
    iRot();
    iRot();

    jRot();

   theLight = new float[3];
   theLight[0] = 0F;
   theLight[1] = 0F;
   theLight[2] = 1F;

   theLight = linearTransform(uRotMx,theLight);
   theLight = linearTransform(uRotMx,theLight);
   theLight = linearTransform(iRotMx,theLight);

  }

} // end of class