/*
 * Arm.java (requires Java 1.2+)
 */

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;
import java.util.*;

class MyImage extends BufferedImage {
    MyImage(int x, int y, int type) { super(x, y, type); }
    public void draw() { }  // Damn compiler wouldn't let me declare it abstract
}

class MyCanvas extends Component {
    MyImage image;
    int w, h;
    MyCanvas(MyImage _image) {
	image= _image;
	w = image.getWidth(null);
	h = image.getHeight(null);
	setSize(w, h);
    }

    public void paint(Graphics g) {
	//System.out.println("MyCanvas.paint()");
	g.drawImage(image, 0, 0, w, h, null);
    }

    public MyImage getImage() { return image; }
}

//-------------------------------------------------------------------------------------------
// A vector object positioned and oriented in space

class VecObj {
    Vector lines;
    VecObj parent;

    double anchorpos[];
    double orientrads[];
    double childAttPt[];  // point in local object coords where a child would attach

    // Scratch values for faster processing...
    double rotx_cosine, rotx_sine;
    double roty_cosine, roty_sine;
    double rotz_cosine, rotz_sine;

    class line {
	double p0[];
	double p1[];
	Color color;
	line(double _p0[], double _p1[], Color _color) {
	    p0= new double[3]; p0[0]= _p0[0];  p0[1]= _p0[1]; p0[2]= _p0[2];
	    p1= new double[3]; p1[0]= _p1[0];  p1[1]= _p1[1]; p1[2]= _p1[2];
	    color = _color;
	}
    }

    VecObj(VecObj _parent) {
	System.gc();
	lines= new Vector();
	anchorpos = new double[3];  anchorpos[0]= 0;  anchorpos[1]= 0;  anchorpos[2]= 0;
	orientrads= new double[3];  orientrads[0]= 0; orientrads[1]= 0; orientrads[2]= 0;
	parent= _parent;
	childAttPt= null;
    }
    VecObj() { this((VecObj)null); }

    public double[] getChildAttPt() { return childAttPt; }
    public void setChildAttPt(double _pt[]) { childAttPt= _pt; }

    final public VecObj getParent() { return parent; }

    final void addLine(double[] p0, double[] p1, Color color) {
	line l= new line(p0, p1, color);
	lines.addElement(l);
    }

    public final void setAnchorPos(double x, double y, double z) {
	anchorpos[0]= x;  anchorpos[1]= y;  anchorpos[2]= z;
    }

    public final void setOrient(double x, double y, double z) {
       orientrads[0]= x;  orientrads[1]= y;  orientrads[2]= z;
    }

    public final void rotateBy(double x, double y, double z) {
       orientrads[0]+= x;  orientrads[1]+= y;  orientrads[2]+= z;
    }

    public final void translateBy(double x, double y, double z) {
	anchorpos[0]+= x;  anchorpos[1]+= y;  anchorpos[2]+= z;
    }

    // Apply rotation and translation...
    protected final void rotate_and_translate(double[] pt, double ret[]) {
	double x2, y2, z2;
	ret[0]= pt[0];  ret[1]= pt[1];  ret[2]= pt[2];

	// Rotate about X axis
	x2= ret[0];
	y2= (ret[1]*rotx_cosine) + (ret[2]*rotx_sine);
	z2= -(ret[1]*rotx_sine) + (ret[2]*rotx_cosine);
	ret[0]= x2;  ret[1]= y2;  ret[2]= z2;

	// Rotate about Y axis
	x2= (ret[0]*roty_cosine) + (ret[2]*roty_sine);
	y2= ret[1];
	z2= -(ret[0]*roty_sine) + (ret[2]*roty_cosine);
	ret[0]= x2;  ret[1]= y2;  ret[2]= z2;

	// Rotate about Z axis
	x2= (ret[0]*rotz_cosine) + (ret[1]*rotz_sine);
	y2= -(ret[0]*rotz_sine) + (ret[1]*rotz_cosine);
	z2= ret[2];
	ret[0]= x2;  ret[1]= y2;  ret[2]= z2;

	if (parent== null) {
	    // Translate to desired position...
	    ret[0]+= anchorpos[0];
	    ret[1]+= anchorpos[1];
	    ret[2]+= anchorpos[2];
	} else {
	    // Move to end of parent arm...
	    double ipt[] = new double[3];  // Scratch
	    // Convert from local coords to parent-relative coords...
	    double[] attpt= parent.getChildAttPt();
	    ipt[0]= ret[0]+ attpt[0];
	    ipt[1]= ret[1]+ attpt[1];
	    ipt[2]= ret[2]+ attpt[2];
	    // Convert from parent-relative coords to absolute coords...
	    parent.rotate_and_translate(ipt, ret);  // Note recursion
	}   
    }
    
    protected final void perspectiveProject(double[] pt) {
	double dist= 600;
	double z= pt[2];
	z+= dist;
	if (z< 1)  z= 1;  // avoid divide-by-zero
	double scale= (600-(400/2))/z;
	pt[0]*= scale;  pt[1]*= scale;
    }


    final void draw(Graphics g) {
	// Precompute some values we'll use repeatedly:
	int w2= 400/2;
	int h2= 400/2;
	rotx_cosine= Math.cos(orientrads[0]);  rotx_sine= Math.sin(orientrads[0]);
	roty_cosine= Math.cos(orientrads[1]);  roty_sine= Math.sin(orientrads[1]);
	rotz_cosine= Math.cos(orientrads[2]);  rotz_sine= Math.sin(orientrads[2]);

	double p0[]= new double[3];
	double p1[]= new double[3];
	for (int i=0; i<lines.size(); i++) {
	    line l = (line) lines.elementAt(i);
	    g.setColor(l.color);
	    rotate_and_translate(l.p0, p0);  perspectiveProject(p0);
	    rotate_and_translate(l.p1, p1);  perspectiveProject(p1);
	    g.drawLine((int)p0[0]+w2, h2-(int)p0[1], (int)p1[0]+w2, h2-(int)p1[1]);
	}
    }
}

//-------------------------------------------------------------------------------------------

class VecObjImage extends MyImage {
    int w, h;
    Vector objs;  // of VecObj

    VecObjImage() {
	super(400, 400, BufferedImage.TYPE_3BYTE_BGR);
	w= 400;  h= 400;
	System.gc();
	objs= new Vector();
    }

    public void addVecObj(VecObj _new) {
	objs.addElement(_new);
    }

    public void draw() {
	Graphics g= createGraphics();
	g.setColor(Color.white);  g.fillRect(0, 0, w, h);  // The background
	for (int i=0; i< objs.size(); i++) {
	    VecObj obj = (VecObj)objs.elementAt(i);
	    obj.draw(g);
	}
    }

}

//-------------------------------------------------------------------------------------------

class VecObjControl extends Panel implements ActionListener {
    VecObj obj; // What we're controlling
    MyCanvas canvas;  // Where we paint
    MyImage image; // Scratch image buffer
    Button bmrx, bmrxm, bmry, bmrym, bmrz, bmrzm;
    Button bmtx= null, bmtxm= null, bmty= null, bmtym= null, bmtz= null, bmtzm= null;
    double rotbyd, rotbyr, xlatby;

    VecObjControl(VecObj _obj, MyCanvas _canvas) {
	obj= _obj;  image= _canvas.getImage();  canvas= _canvas;

	setLayout(new GridLayout(2,1));

	Panel prot= new Panel();
	bmrx = new Button("RotX+");  prot.add(bmrx);  bmrx.addActionListener(this);
	bmrxm = new Button("RotX-");  prot.add(bmrxm);  bmrxm.addActionListener(this);
	bmry = new Button("RotY+");  prot.add(bmry);  bmry.addActionListener(this);
	bmrym = new Button("RotY-");  prot.add(bmrym);  bmrym.addActionListener(this);
	bmrz = new Button("RotZ+");  prot.add(bmrz);  bmrz.addActionListener(this);
	bmrzm = new Button("RotZ-");  prot.add(bmrzm);  bmrzm.addActionListener(this);
	add(prot);

	if (obj.getParent()== null) {
	    // It's the root object, so we can translate it
	    Panel pxl= new Panel();
	    bmtx = new Button("XlatX+");  pxl.add(bmtx);  bmtx.addActionListener(this);
	    bmtxm = new Button("XlatX-");  pxl.add(bmtxm);  bmtxm.addActionListener(this);
	    bmty = new Button("XlatY+");  pxl.add(bmty);  bmty.addActionListener(this);
	    bmtym = new Button("XlatY-");  pxl.add(bmtym);  bmtym.addActionListener(this);
	    bmtz = new Button("XlatZ+");  pxl.add(bmtz);  bmtz.addActionListener(this);
	    bmtzm = new Button("XlatZ-");  pxl.add(bmtzm);  bmtzm.addActionListener(this);
	    add(pxl);
	}

	rotbyd= 15;
	rotbyr= rotbyd* 3.14159/180;
	xlatby= 20;
    }
    
    public void actionPerformed(ActionEvent event)   {
	Object source = event.getSource();
	//System.out.println("ACTION_EVENT");
	if (source== bmrx)   obj.rotateBy(rotbyr, 0, 0);
	else  if (source== bmrxm)    obj.rotateBy(-rotbyr, 0, 0);
	else  if (source== bmry)     obj.rotateBy(0, rotbyr, 0);
	else  if (source== bmrym)    obj.rotateBy(0, -rotbyr, 0);
	else  if (source== bmrz)     obj.rotateBy(0, 0, rotbyr);
	else  if (source== bmrzm)    obj.rotateBy(0, 0, -rotbyr);
	else  if (source== bmtx)     obj.translateBy(xlatby, 0, 0);
	else  if (source== bmtxm)    obj.translateBy(-xlatby, 0, 0);
	else  if (source== bmty)     obj.translateBy(0, xlatby, 0);
	else  if (source== bmtym)    obj.translateBy(0, -xlatby, 0);
	else  if (source== bmtz)     obj.translateBy(0, 0, xlatby);
	else  if (source== bmtzm)    obj.translateBy(0, 0, -xlatby);
	image.draw();
	canvas.repaint();
    }
}

//-------------------------------------------------------------------------------------------

class VecObjArmMaker {
    // Builds a globe in a VecObj
    VecObj obj;  // What we're acting upon
    double len;

    VecObjArmMaker(VecObj _obj, double _len) {
	obj= _obj;
	len= _len;
	createLines();
    }
    
    static void MultByLen(double[] xyz, double _len) {
	xyz[0]*= _len;
	xyz[1]*= _len;
	xyz[2]*= _len;
    }

    void createLines() {
	double p1[]= new double[3];  p1[0]= -0.1;  p1[1]= -0.05; p1[2]= 0;  MultByLen(p1, len);
	double p2[]= new double[3];  p2[0]= -0.1;  p2[1]= 0.05; p2[2]= 0;  MultByLen(p2, len);
	double p3[]= new double[3];  p3[0]= 0.1;  p3[1]= 0; p3[2]= 0;  MultByLen(p3, len);
	double pe[]= new double[3];  pe[0]= 0;  pe[1]= 0; pe[2]= 1;  MultByLen(pe, len);
	obj.addLine(p1, pe, Color.blue);
	obj.addLine(p2, pe, Color.blue);
	obj.addLine(p3, pe, Color.green);
	obj.addLine(p1, p2, Color.red);
	obj.addLine(p2, p3, Color.red);
	obj.addLine(p1, p3, Color.black);
	obj.setChildAttPt(pe);
    }

}

//-------------------------------------------------------------------------------------------

class VecObjFloorMaker {
    // Builds a floor in a VecObj
    VecObj obj;  // What we're acting upon
    double wid;

    VecObjFloorMaker(VecObj _obj, double _wid) {
	obj= _obj;  wid= _wid;
	createLines();
    }

    void createLines() {
	double wid2= wid/2;
	int steps= 8;
	double step= wid/steps;
	int xcount;  double x= -wid2;
	int zcount;  double z= -wid2;
	double p0[]= new double[3];
	double p1[]= new double[3];
	p0[1]= p1[1]= -wid2;
	p0[2]= wid2;  p1[2]= -wid2;
	for (xcount= 0; xcount<= steps; xcount++) {
	    p0[0]= p1[0]= x;  x+= step;
            obj.addLine(p0, p1, Color.black);
	}
	p0[0]= wid2;  p1[0]= -wid2;
	for (zcount= 0; zcount<= steps; zcount++) {
	    p0[2]= p1[2]= z;  z+= step;
            obj.addLine(p0, p1, Color.black);
	}
    }
}


//-------------------------------------------------------------------------------------------

public class Arm extends Frame implements WindowListener {
    MyCanvas canvas;
    VecObjControl arm1ctrl;
    VecObjControl arm2ctrl;
    VecObjImage image;

    Arm() {
	super("Arm in Java");
	addWindowListener(this);
	setLayout(new BorderLayout());

	VecObj floor= new VecObj();  new VecObjFloorMaker(floor, 400);
	VecObj arm1= new VecObj();  new VecObjArmMaker(arm1, 150);
	VecObj arm2= new VecObj(arm1);  new VecObjArmMaker(arm2, 100);

	image= new VecObjImage();
	image.addVecObj(floor);
	image.addVecObj(arm1);
	image.addVecObj(arm2);
	image.draw();
	canvas= new MyCanvas(image);  add("Center", canvas);  // "North" doesn't work

	arm1ctrl= new VecObjControl(arm1, canvas);	add("North", arm1ctrl);
	arm2ctrl= new VecObjControl(arm2, canvas);	add("South", arm2ctrl);
	setSize(image.getWidth(), image.getHeight()+100);
	show();
    }

    // What a pain...
    public void windowActivated(WindowEvent event) { }
    public void windowDeactivated(WindowEvent event) { }
    public void windowClosed(WindowEvent event) { }
    public void windowIconified(WindowEvent event) { }
    public void windowDeiconified(WindowEvent event) { }
    public void windowOpened(WindowEvent event) { }
    public void windowClosing(WindowEvent event) {
	System.exit(0);
    }

    public static void main(String[] args) {
	Arm inst = new Arm(); // create frame with title
    } // end main
}