import javax.microedition.lcdui.*;

public class Canvas3D extends Canvas implements Runnable {
    
    Graphics buf;
    Image mem;
    
    Thread th;

    int x = 200 << 16;
    int y = 52;
    
    int f = (x/y) >> 16;
    
    Matrix4x4 m;
    
    boolean roll = true;
    
    Vertex[] vts;
    
    public Canvas3D() {
	
	vts = new Vertex[8];
	vts[0] = new Vertex(-20, -20, -20);
	vts[1] = new Vertex(20, -20, -20);
	vts[2] = new Vertex(20, -20, 20);
	vts[3] = new Vertex(-20, -20, 20);
	vts[4] = new Vertex(-20, 20, -20);
	vts[5] = new Vertex(20, 20, -20);
	vts[6] = new Vertex(20, 20, 20);
	vts[7] = new Vertex(-20, 20, 20);
	
	
	m = new Matrix4x4();
	
	mem = Image.createImage(getWidth(), getHeight());
	buf = mem.getGraphics();
	
    }
    
    public void paint(Graphics g) {
	
	g.drawImage(mem, 0, 0, Graphics.LEFT | Graphics.TOP);
	
    }
    
    public void start() {

	th = new Thread(this);
	th.start();
	
    }
    
    
    public void run() {
	
	while(roll) {
	    
	    for(int i=0; i<360; i++) {
		
		m.rotate(i, i, i);
		
		for(int n=0; n<8; n++)
		    m.transform(vts[n]);
		
		buf.setColor(0xFFFFFF);
		buf.fillRect(0, 0, getWidth(), getHeight());
		buf.setColor(0x000000);
		
		for(int n=0; n<8; n++)
		    buf.fillRect(48+vts[n].rx, 50+vts[n].ry, 2, 2);
		
		buf.drawLine(48+vts[0].rx, 50+vts[0].ry, 48+vts[1].rx, 50+vts[1].ry);
		buf.drawLine(48+vts[1].rx, 50+vts[1].ry, 48+vts[2].rx, 50+vts[2].ry);
		buf.drawLine(48+vts[2].rx, 50+vts[2].ry, 48+vts[3].rx, 50+vts[3].ry);
		buf.drawLine(48+vts[3].rx, 50+vts[3].ry, 48+vts[0].rx, 50+vts[0].ry);
		
		buf.drawLine(48+vts[4].rx, 50+vts[4].ry, 48+vts[5].rx, 50+vts[5].ry);
		buf.drawLine(48+vts[5].rx, 50+vts[5].ry, 48+vts[6].rx, 50+vts[6].ry);
		buf.drawLine(48+vts[6].rx, 50+vts[6].ry, 48+vts[7].rx, 50+vts[7].ry);
		buf.drawLine(48+vts[7].rx, 50+vts[7].ry, 48+vts[4].rx, 50+vts[4].ry);
		
		buf.drawLine(48+vts[0].rx, 50+vts[0].ry, 48+vts[4].rx, 50+vts[4].ry);
		buf.drawLine(48+vts[1].rx, 50+vts[1].ry, 48+vts[5].rx, 50+vts[5].ry);
		buf.drawLine(48+vts[2].rx, 50+vts[2].ry, 48+vts[6].rx, 50+vts[6].ry);
		buf.drawLine(48+vts[3].rx, 50+vts[3].ry, 48+vts[7].rx, 50+vts[7].ry);
		
		//System.out.println(i+": "+rv[0]+", "+rv[1]+", "+rv[3]);
		
		repaint();
		
		try {
		    th.sleep(20);
		} catch(InterruptedException ie) {
		    ie.printStackTrace();
		}

	    }

	}
	
    }

    
    class Matrix4x4 {
	
	int[][] rx, ry, rz, mat;
	int[] sin, cos;
	
	public Matrix4x4() {
	    
	    rx = new int[4][4];
	    ry = new int[4][4];
	    rz = new int[4][4];
	    mat = new int[4][4];
	    
	    ident(rx);
	    ident(ry);
	    ident(rz);
	    ident(mat);
	    
	    sin = new int[360];
	    cos = new int[360];
	    
	    sin[0] = 0; cos[0] = 255;
	    sin[1] = 4; cos[1] = 254;
	    sin[2] = 8; cos[2] = 254;
	    sin[3] = 13; cos[3] = 254;
	    sin[4] = 17; cos[4] = 254;
	    sin[5] = 22; cos[5] = 254;
	    sin[6] = 26; cos[6] = 253;
	    sin[7] = 31; cos[7] = 253;
	    sin[8] = 35; cos[8] = 252;
	    sin[9] = 39; cos[9] = 251;
	    sin[10] = 44; cos[10] = 251;
	    sin[11] = 48; cos[11] = 250;
	    sin[12] = 53; cos[12] = 249;
	    sin[13] = 57; cos[13] = 248;
	    sin[14] = 61; cos[14] = 247;
	    sin[15] = 65; cos[15] = 246;
	    sin[16] = 70; cos[16] = 245;
	    sin[17] = 74; cos[17] = 243;
	    sin[18] = 78; cos[18] = 242;
	    sin[19] = 83; cos[19] = 241;
	    sin[20] = 87; cos[20] = 239;
	    sin[21] = 91; cos[21] = 238;
	    sin[22] = 95; cos[22] = 236;
	    sin[23] = 99; cos[23] = 234;
	    sin[24] = 103; cos[24] = 232;
	    sin[25] = 107; cos[25] = 231;
	    sin[26] = 111; cos[26] = 229;
	    sin[27] = 115; cos[27] = 227;
	    sin[28] = 119; cos[28] = 225;
	    sin[29] = 123; cos[29] = 223;
	    sin[30] = 127; cos[30] = 220;
	    sin[31] = 131; cos[31] = 218;
	    sin[32] = 135; cos[32] = 216;
	    sin[33] = 138; cos[33] = 213;
	    sin[34] = 142; cos[34] = 211;
	    sin[35] = 146; cos[35] = 208;
	    sin[36] = 149; cos[36] = 206;
	    sin[37] = 153; cos[37] = 203;
	    sin[38] = 156; cos[38] = 200;
	    sin[39] = 160; cos[39] = 198;
	    sin[40] = 163; cos[40] = 195;
	    sin[41] = 167; cos[41] = 192;
	    sin[42] = 170; cos[42] = 189;
	    sin[43] = 173; cos[43] = 186;
	    sin[44] = 177; cos[44] = 183;
	    sin[45] = 180; cos[45] = 180;
	    sin[46] = 183; cos[46] = 177;
	    sin[47] = 186; cos[47] = 173;
	    sin[48] = 189; cos[48] = 170;
	    sin[49] = 192; cos[49] = 167;
	    sin[50] = 195; cos[50] = 163;
	    sin[51] = 198; cos[51] = 160;
	    sin[52] = 200; cos[52] = 156;
	    sin[53] = 203; cos[53] = 153;
	    sin[54] = 206; cos[54] = 149;
	    sin[55] = 208; cos[55] = 146;
	    sin[56] = 211; cos[56] = 142;
	    sin[57] = 213; cos[57] = 138;
	    sin[58] = 216; cos[58] = 135;
	    sin[59] = 218; cos[59] = 131;
	    sin[60] = 220; cos[60] = 127;
	    sin[61] = 223; cos[61] = 123;
	    sin[62] = 225; cos[62] = 119;
	    sin[63] = 227; cos[63] = 115;
	    sin[64] = 229; cos[64] = 111;
	    sin[65] = 231; cos[65] = 107;
	    sin[66] = 232; cos[66] = 103;
	    sin[67] = 234; cos[67] = 99;
	    sin[68] = 236; cos[68] = 95;
	    sin[69] = 238; cos[69] = 91;
	    sin[70] = 239; cos[70] = 87;
	    sin[71] = 241; cos[71] = 83;
	    sin[72] = 242; cos[72] = 78;
	    sin[73] = 243; cos[73] = 74;
	    sin[74] = 245; cos[74] = 70;
	    sin[75] = 246; cos[75] = 66;
	    sin[76] = 247; cos[76] = 61;
	    sin[77] = 248; cos[77] = 57;
	    sin[78] = 249; cos[78] = 53;
	    sin[79] = 250; cos[79] = 48;
	    sin[80] = 251; cos[80] = 44;
	    sin[81] = 251; cos[81] = 39;
	    sin[82] = 252; cos[82] = 35;
	    sin[83] = 253; cos[83] = 31;
	    sin[84] = 253; cos[84] = 26;
	    sin[85] = 254; cos[85] = 22;
	    sin[86] = 254; cos[86] = 17;
	    sin[87] = 254; cos[87] = 13;
	    sin[88] = 254; cos[88] = 8;
	    sin[89] = 254; cos[89] = 4;
	    sin[90] = 255; cos[90] = 0;
	    
	    int p = 0;
	    
	    for(int i=90; i<180; i++) {
		sin[i] = sin[90-p];
		cos[i] = -cos[90-p];
		p++;
	    }
	    
	    p = 0;
	    
	    for(int i=180; i<360; i++) {
		sin[i] = -sin[p];
		cos[i] = -cos[p];
		p++;
	    }
			     
	}
	
	
	public void ident(int[][] matrix) {
	    
	    for(int i=0; i<4; i++)
		for(int j=0; j<4; j++)
		    matrix[i][j] = 0;
	    
	    matrix[0][0] = 255;
	    matrix[1][1] = 255;
	    matrix[2][2] = 255;
	    matrix[3][3] = 255;
	    
	}

	
	public void rotate(int ax, int ay, int az) {
	    
	    rx[1][1] = cos[ax];
	    rx[1][2] = sin[ax];
	    rx[2][1] = -sin[ax];
	    rx[2][2] = cos[ax];
	    
	    ry[0][0] = cos[ay];
	    ry[0][2] = -sin[ay];
	    ry[2][0] = sin[ay];
	    ry[2][2] = cos[ay];
	    
	    rz[0][0] = cos[az];
	    rz[0][1] = sin[az];
	    rz[1][0] = -sin[az];
	    rz[1][1] = cos[az];
	    
	}

	
	public void mult(int[][] a, int[][] b) {
	    
	    int i, j;
	    int[][] tmp = new int[4][4];
	    
	    for (j = 0; j < 4; j++)                 
		for (i = 0; i < 4; i++)             
		    tmp[i][j] = 
			((a[i][0] * b[0][j])>>8) + 
			((a[i][1] * b[1][j])>>8) + 
			((a[i][2] * b[2][j])>>8) + 
			((a[i][3] * b[3][j])>>8);
	    
	    for (i = 0; i < 4; i++)                 
		for (j = 0; j < 4; j++)
		    a[i][j] = tmp[i][j];
	    
	}
	
	
	public void transform(Vertex p, int[][] matrix) {
	    
	    
	    p.rx = 
		((p.x * matrix[0][0])>>8) 
		+ ((p.y * matrix[1][0])>>8)
		+ ((p.z * matrix[2][0])>>8)
		+ ((p.w * matrix[3][0])>>8);
	    
	    p.ry = 
		((p.x * matrix[0][1])>>8)
		+ ((p.y * matrix[1][1])>>8)
		+ ((p.z * matrix[2][1])>>8)
		+ ((p.w * matrix[3][1])>>8);
	    
	    p.rz = 
		((p.x * matrix[0][2])>>8)
		+ ((p.y * matrix[1][2])>>8)
		+ ((p.z * matrix[2][2])>>8)
		+ ((p.w * matrix[3][2])>>8);
	    
	    p.rw = 
		((p.x * matrix[0][3])>>8)
		+ ((p.y * matrix[1][3])>>8)
		+ ((p.z * matrix[2][3])>>8)
		+ ((p.w * matrix[3][3])>>8);
	    
	    
	    /*
	    d[0] = 
		((o[0] * matrix[0][0]) 
		 + (o[1] * matrix[1][0])
		 + (o[2] * matrix[2][0])
		 + (o[3] * matrix[3][0]));
	    
	    d[1] = 
		((o[0] * matrix[0][1])
		 + (o[1] * matrix[1][1])
		 + (o[2] * matrix[2][1])
		 + (o[3] * matrix[3][1]));
	    
	    d[2] = 
		((o[0] * matrix[0][2])
		 + (o[1] * matrix[1][2])
		 + (o[2] * matrix[2][2])
		 + (o[3] * matrix[3][2]));
	    
	    d[3] = 
		((o[0] * matrix[0][3])
		 + (o[1] * matrix[1][3])
		 + (o[2] * matrix[2][3])
		 + (o[3] * matrix[3][3]));

	    */
	    
	}

	public void transform(Vertex p) {
	    
	    ident(mat);
	    mult(mat, rx);
	    mult(mat, ry);
	    mult(mat, rz);
	    
	    transform(p, mat);
	    
	}
	
	
    }

    
    class Vertex {

	int x, y, z, w, rx, ry, rz, rw;

	public Vertex(int x, int y, int z) {
	    
	    this.x = x;
	    this.y = y;
	    this.z = z;
	    
	    rx = x;
	    ry = y;
	    rz = z;
	    
	    w = 1; rw = 1;

	}
    
    }
    
    
}