/* Display of wire-frame model of cube  by T.Nishita
	class point3; 頂点の３次元座標
	class Plane; 多面体の構成面
	class Trans; 座標変換
*/
import java.applet.*;
import java.awt.*;
//import java.io.*;
//import java.awt.event.*;      // for JDK1.2

public class wire extends java.applet.Applet
//	 implements MouseListener, MouseMotionListener // for JDK1.2
 {	int x_origin,y_origin;             // origin(center) of screen
	double theta=70., phi=20., R=800.; // viewpoint
	Point prev = new Point(0, 0);

	Trans henkan = new Trans();
	Plane face[];    // face
	int npoints;     //  number of vertices
	int nplanes;     //  number of faces
	Point3 point[];  //  coordinates of vertices

/* **************************************************************: */
    public void init() {
		double scale=70.;    //scale(size) of cube

		setBackground(Color.lightGray);    // set Background
// for JDK1.
		Dimension appsize = size();	    	// for JDK1.0		
	    x_origin = appsize.width/2;
		y_origin = appsize.height/2;
//for JDK1.2
/*
//		resize(getSize().width, getSize().height);    	
		x_origin = getSize().width/2; 	
		y_origin = getSize().height/2;
		addMouseListener(this);
		addMouseMotionListener(this);
*/
        henkan.setVRpnt(0.,0.,0.);      // set viewreference point
        henkan.setview(R,theta,phi);    // set viewpoint
		model(scale);                   // modeling of cube
    }
/* *************** paint function *****************************: */
    public void paint(Graphics g) {
	Point[] tPoint = new Point[npoints];  //  projected points

	 henkan.preper();              // set coefficients of transformation-matrix
	 g.setColor(Color.black);
	for (int i = 0; i < npoints; i++) 
		 tPoint[i] = henkan.project(point[i]);
	for(int i=0;i<nplanes; i++)     // draw polygons
		face[i].draw(g,x_origin,y_origin,tPoint);
   }
//  ------------- modeling of cube ----------------------------- 
    public void model(double scale) {
		int element[][] = { // face
			{0, 1, 2, 3},
			{1, 4, 7, 2}, 
			{4, 5, 6, 7},
			{0, 3, 6, 5}, 
			{5, 4, 1, 0}, 
			{2, 7, 6, 3} 
		};
		double pnt[][]={   // vertex
			{1.000000, -1.000000, 1.000000},
			{1.000000, 1.000000, 1.000000},
			{1.000000, 1.000000, -1.000000},
			{1.000000, -1.000000, -1.000000},
			{-1.000000, 1.000000, 1.000000},
			{-1.000000, -1.000000, 1.000000},
			{-1.000000, -1.000000, -1.000000},
			{-1.000000, 1.000000, -1.000000}
		};
		npoints = 8;
		point = new Point3[npoints];
		for(int k=0;k<npoints;k++)
		 point[k] = new Point3(scale*pnt[k][0],scale *pnt[k][1],
			scale *pnt[k][2]);

		nplanes = 6;
		face = new Plane[nplanes];
		for(int i=0;i<nplanes;i++){
			face[i] = new Plane();
			for(int j=0;j<4;j++) face[i].add(element[i][j]);
		}
	}
// ***********   event handling *********************************:
	public boolean mouseDown(Event evt, int x, int y) {
		prev = new Point(x, y);
		repaint();
		return true;
    }
// ------------------------------------------------------------------
	public boolean mouseDrag(Event ev, int x, int y) {

		theta += (double)(prev.x-x) * (180.0 /x_origin);
		phi += (double)(y-prev.y) * (180.0 /y_origin);
		henkan.setview(R,theta,phi); 
		repaint();
		prev.move(x, y);
		return true;
	}
// ------------------------------------------------------------------
	public boolean mouseUp(Event ev, int x, int y) {
		prev = null;
		return true;
	}

/*
  public void mousePressed(MouseEvent e) {
		prev = new Point(e.getX(),e.getY());
		repaint();
 } 
  public void mouseDragged(MouseEvent e) {
	theta += (double)(prev.x-e.getX()) * (180.0 /x_origin);
	phi += (double)(e.getY()-prev.y) * (180.0 /y_origin);
	henkan.setview(R,theta,phi); 
	repaint();
	prev.move(e.getX(),e.getY());
  }
  public void mouseReleased(MouseEvent e) {
		prev = null;
  }
  public void mouseClicked(MouseEvent e) {
  }   
  public void mouseEntered(MouseEvent e) {
  }
  public void mouseExited(MouseEvent e) {
  }   
  public void mouseMoved(MouseEvent e) { 
  }
*/
}

//  Plane class of a polygon
class Plane {
	public int set[];        // the set of index to point constituting a plane
	public int npoint=0;      // # of points constituting a plane

    Plane() { //		npoint=0; 
		set = new int[4];
	}
    public void add(int k) {
		set[npoint] = k;
		npoint ++;
	}

    public void draw(Graphics g, int x_origin,int y_origin,Point3 point[]) {

	for (int i = 0; i < npoint; i++) {
      int ii = i+1; if(ii==npoint) ii=0;
	  g.drawLine((int)(point[set[i]].x/point[set[i]].z)+x_origin, 
		y_origin-(int)(point[set[i]].y/point[set[i]].z),
			   (int)(point[set[ii]].x/point[set[ii]].z)+x_origin,y_origin
		-(int)(point[set[ii]].y/point[set[ii]].z));
		}
	}

    public void draw(Graphics g, int x_origin,int y_origin,Point point[]) {

	for (int i = 0; i < npoint; i++) {
      int ii = i+1; if(ii==npoint) ii=0;
	   g.drawLine(point[set[i]].x+x_origin, y_origin-point[set[i]].y, 
	   point[set[ii]].x+x_origin, y_origin-point[set[ii]].y); }
	}
}

// ---------- Class for transformation ----------------
class Trans {
	double  cos_theta=1., cos_phi=1., sin_theta=0., sin_phi=0.;
	Point3 ptViewRef = new Point3(0, 0, 0);   // view reference point
	double theta, phi, R;

	Trans() {
	}
// set view-reference point
  public void setVRpnt( double x, double y, double z) {
     ptViewRef = new Point3(x,y,z);
  }
// set viewpoint
  public void setview(double r, double the, double ph) {
     theta=the; phi=ph; R=r;
  }

//  set matrix for   perspective transformation  
  public void preper() {
		double d2r= Math.PI/180;

		cos_theta = Math.cos(theta*d2r);
		sin_theta = Math.sin(theta*d2r);
		cos_phi = Math.cos(phi*d2r);
		sin_phi = Math.sin(phi*d2r);
	}
//  Transform world coordinate-system to viewpoint coordinate-system.
	public Point3 tranfrm(Point3 point) {
		Point3 p1 = new Point3();
		Point3 p2 = new Point3();

		p1.x = point.x - ptViewRef.x;
		p1.y = point.y - ptViewRef.y;
		p1.z = point.z - ptViewRef.z;

    	double xy = cos_theta*p1.x+sin_theta*p1.y; 	
		p2.z =(R-cos_phi*xy-sin_phi*p1.z)/R;
	    p2.x = cos_theta*p1.y-sin_theta*p1.x;	
		p2.y = cos_phi * p1.z - sin_phi * xy;

		return p2;
	}
	public Point project(Point3 point) {
		Point3 p1= tranfrm(point);
		return new Point((int)(p1.x/p1.z), (int)(p1.y/p1.z)); 
	}
}

// 3D real point class 
class Point3 {
	public double x, y, z;

	Point3() {
	}
	Point3(double ox, double oy, double oz) {
	x = ox; y = oy; z = oz;
	}
}