//package matrices;

import java.awt.*;

public class House extends BufferedApplet
{
    double margin = 0.5;
    double cubesize = 0.5;

    double cubepoints[][][] = {
	{{0+margin,0+margin,0,1},
	 {cubesize+margin,0+margin,0,1},
	 {cubesize+margin,cubesize+margin,0,1},
	 {0+margin,cubesize+margin,0,1},
	 {0+margin,0+margin,0,1}},
	{{0+margin,0+margin,cubesize,1},
	 {cubesize+margin,0+margin,cubesize,1},
	 {cubesize+margin,cubesize+margin,cubesize,1},
	 {0+margin,cubesize+margin,cubesize,1},
	 {0+margin,0+margin,cubesize,1}},
	{{0+margin,0+margin,0,1},
	 {0+margin,0+margin,cubesize,1}},
	{{cubesize+margin,0+margin,0,1},
	 {cubesize+margin,0+margin,cubesize,1}},
	{{0+margin,cubesize+margin,0,1},
	 {0+margin,cubesize+margin,cubesize,1}},
	{{cubesize+margin,cubesize+margin,0,1},
	 {cubesize+margin,cubesize+margin,cubesize,1}}
    };

    // All this verbiage is responsible for calculating the vertices of a centered
    // icosahedron

    double S  = 1;
    double t1 = 2 * Math.PI / 5;
    double t2 = Math.PI / 10;
    double t4 = Math.PI / 5 ;
    double t3 = -3 * Math.PI / 10;
    double R  = (S/2) / Math.sin(t4);
    double H  = Math.cos(t4) * R;
    double Cx = R * Math.cos(t2);
    double Cy = R * Math.sin(t2);

    double H1 = Math.sqrt(S*S - R*R);
    double H2 = Math.sqrt((H+R) * (H + R) - (H*H));

    double Z2 = (H2 - H1) / 2;
    double Z1 = Z2 + H1;
    
    double aa[] = {   0-margin,   0-margin,  Z1, 1};
    double bb[] = {   0-margin,   R-margin,  Z2, 1};
    double cc[] = {  Cx-margin,  Cy-margin,  Z2, 1};
    double dd[] = { S/2-margin,  -H-margin,  Z2, 1};
    double ee[] = {-S/2-margin,  -H-margin,  Z2, 1};
    double ff[] = { -Cx-margin,  Cy-margin,  Z2, 1};
    double gg[] = {   0-margin,  -R-margin, -Z2, 1};
    double hh[] = { -Cx-margin, -Cy-margin, -Z2, 1};
    double ii[] = {-S/2-margin,   H-margin, -Z2, 1};
    double jj[] = { S/2-margin,   H-margin, -Z2, 1};
    double kk[] = {  Cx-margin, -Cy-margin, -Z2, 1};
    double ll[] = {   0-margin,   0-margin, -Z1, 1};

    double icopoints[][][] = {
	{aa,bb,cc},
	{aa,cc,dd},
	{aa,dd,ee},
	{aa,ee,ff},
	{aa,ff,bb},
	{bb,cc,jj},
	{bb,jj,ii},
	{bb,ii,ff},
	{ff,ii,hh},
	{ff,hh,ee},
	{ee,gg,dd},
	{ee,hh,gg},
	{gg,dd,kk},
	{kk,dd,cc},
	{kk,cc,jj},
	{ll,kk,jj},
	{ll,ii,hh},
	{ll,hh,gg},
	{ll,gg,kk},
	{ll,jj,ii}
    };


    double a[] = {0,0,0,0}, b[] = {0,0,0,0};
    double c[] = {0,0,0,0}, d[] = {0,0,0,0};
    int w, h, frame = 0;
    double t = 0;
    Matrix3D Xrotate = new Matrix3D();

    Matrix3D littleXrot = new Matrix3D();
    Matrix3D littleScale = new Matrix3D();


    double points[][][] = cubepoints;



    public void init() {
	super.init();
	//	double points[][][] = icopoints;
	littleXrot.xRotationMatrix(Math.PI/3000);
	littleScale.scaleMatrix(1.001,1.001,1.001);
    }

    public void render(Graphics g) {
	w = bounds().width;
	h = bounds().height;
	g.setColor(Color.white);
	g.fillRect(0,0,w,h);
	g.setColor(Color.blue);

	t = .5 + .5*Math.sin(.03 * frame++);
	double zz = t*100;
	int yy = (int) zz;
	Color myColor = new Color(yy,100,20);
	g.setColor(myColor);
	for (int i = 0 ; i < icopoints.length ; i++)
	    for (int j = 1 ; j < icopoints[i].length ; j++) { 
		transform(icopoints[i][j-1], a);
		transform(icopoints[i][j  ], b);
		g.drawLine(x(a[0]), y(a[1]), x(b[0]), y(b[1]));
	    }
	for (int i = 0 ; i < cubepoints.length ; i++)
	    for (int j = 1 ; j < cubepoints[i].length ; j++) { 
		transform(cubepoints[i][j-1], a);
		transform(cubepoints[i][j  ], b);
		g.drawLine(x(a[0]), y(a[1]), x(b[0]), y(b[1]));
	    }
    }

    int x(double t) { return w/2 + (int)(t*w/4); } // CONVERT X COORDINATE TO SCREEN PIXELS
    int y(double t) { return h/2 - (int)(t*w/4); } // CONVERT Y COORDINATE TO SCREEN PIXELS

    void transform(double src[], double dst[]) {

	Matrix3D M = new Matrix3D();

	M.Identity();

	M.xRotate(2*Math.PI * t);
	M.zRotate(2*Math.PI * t);
	M.yRotate(2*Math.PI * t);

	M.translate(.3*t,.3*t,.3*t);
	//	M.Scale(1+.1*t,
	//	1+.1*t,
	//	1+.1*t);
		

	M.transform(src,dst);
    }
}