/*
<?xml version='1.0' standalone='yes' ?>
<!--  xml header for scripts & plugin manager --> 
<script>
	<name>Mirror Skeleton *on stereoids*</name>
	<author>Petri Ihalainen</author>
	<version>1.1</version>
	<date>28/08/2010</date>
	<description>
	Mirrors a partially created skeleton in x,y,or z. 

	The On-Axis Tolerance field in the dialogue is to prevent mirroring of joints
	which are not exactly aligned with the root, e.g. to allow for slight
	variations along a spine. Any joints within this distance of the root will
	not be mirrored uless it's child to an already mirrored joint.
	</description>
    
	<comments>
	This script is based on Julian MacDonald's original "Mirror Skeleton" script, 
	but the code has been entirely rewritten. Now it handles the skeleton recursively, 
	satrting form the selected joint (if the user chooses so).
  
	Unfortunately it was not possible to mirror the joints inside the recursion tree.
	The attempts looped Java for good. Hence the implementation with a set of 
	lists of parents, mirrorability, order of mirroring...
	</comments>
    
</script>
*/

import artofillusion.animation.*;

//***************************
//    --- methods---
//***************************

// Generating a reorganizing the joint list so, 
// that parents appear before children.

Joint[] AddJointWithChildren(Joint joint, Joint[] oldList)
{	
	int i; // This is neceassary in the script

	newList = new Joint[oldList.length+1];
	System.arraycopy(oldList, 0, newList, 0, oldList.length);
	newList[oldList.length]=joint;

	for (i=0;i<joint.children.length;i++)
		newList = AddJointWithChildren(joint.children[i], newList);
		
	return newList;
}

int RootCount (Joint[] j)
{
	rc = 0;
	for (b=0;b<j.length;b++)
	{  
		if (origJoints[b].parent == null) rc++;
	}
	return (rc);
}

Joint[] Roots(Joint[] j)
{
	r = new Joint[RootCount(j)];
	ri=0;
	for (b=0;b<j.length;b++)
		if (origJoints[b].parent == null)
		{
			r[ri]=j[b];
			ri++;
		}
	return (r);
}

int[] RootIndexes(Joint[] j)
{
	ri = new int[RootCount(j)];
	k=0;
	
	for (i=0;i<j.length;i++)
		if (j[i].parent == null){
	  	ri[k]=i;
	  	k++;
		}
	return (ri);
}

String[] RootNames(Joint[] roots)
{
	names = new String[roots.length];
	
	for (i=0;i<roots.length;i++){
		names[i]=roots[i].name;
	}
	return (names);
}

int[] ParentIndexes(Joint[] j)
{
	pi = new int[j.length];
	
	for (i=0;i<pi.length;i++){
		for (k=0;k<pi.length;k++){
			if (j[i].parent == null)
				pi[i]=-1;
	  	if (j[i].parent != null && j[i].parent.id == j[k].id)
	  		pi[i]=k;}
	}
	return (pi);
}

Joint[] ParentList(Joint[] list)
{
	parentList = new Joint[list.length];
	for (i=0;i<list.length;i++)
	{
		if (list[i].parent != null)
		{
			parentList[i] = list[i].parent;
		}
		else
			parentList[i] = null;
	}

	return parentList;
}

// The "MirroringList" and the "MirrorJoints" methods could basically be 
// combined. However it was easier to keep the logic clear this way

boolean[] MirroringList(Joint[] orderedList, int dir, double tol, double mOff, int[] parentIndexList)
{
	mirroringList = new boolean[orderedList.length];
	for (i=0;i<orderedList.length;i++)
	{
		coords = orderedList[i].coords.duplicate();
		position = coords.getOrigin();
		
		toMirror = false;
		
		if (parentIndexList[i] > -1)
			if (mirroringList[parentIndexList[i]] == true)
				toMirror = true;

		if (dir == 0)
			if (Math.abs(position.x-mOff) > tol)
				toMirror = true;
			
		if (dir == 1)
			if (Math.abs(position.y-mOff) > tol)
				toMirror = true;
			
		if (dir == 2)
			if (Math.abs(position.z-mOff) > tol)
				toMirror = true;	
		
		mirroringList[i] = toMirror;
	}
	return mirroringList;
}


// This is what actually does the work.
void MirrorJoints
	(	Joint[] jointsInOrder, boolean[] mirroringList, int[] parentIndexList, 
		Joint[] parentList, int dir, double tol, double mOff, Skeleton skeleton)
{ 
	for (i=0;i<jointsInOrder.length;i++)
	{
		if (mirroringList[i] == true)
		{
			newCoords = jointsInOrder[i].coords.duplicate();
		
			if (dir == 0)
			{
				newCoords.getOrigin().x = 2*mOff-newCoords.getOrigin().x;
				newCoords.getZDirection().x = -newCoords.getZDirection().x;
				newCoords.getUpDirection().x= -newCoords.getUpDirection().x;				
			}
			if (dir == 1)
			{
				newCoords.getOrigin().y = 2*mOff-newCoords.getOrigin().y;
				newCoords.getZDirection().y = -newCoords.getZDirection().y;
				newCoords.getUpDirection().y= -newCoords.getUpDirection().y;				
			}
			if (dir == 2)
			{
				newCoords.getOrigin().z = 2*mOff-newCoords.getOrigin().z;
				newCoords.getZDirection().z = -newCoords.getZDirection().z;
				newCoords.getUpDirection().z= -newCoords.getUpDirection().z;				
			}

			parentJoint = parentList[i];

			// When mirroring a partial skeleton, check if a new root is needed.
			if (i==0 && parentJoint != null)
			{
				conn = ConnectToParent(newCoords.getOrigin(), jointsInOrder[i].coords.getOrigin(),
					parentJoint.coords.getOrigin(),dir,tol);
				if (!conn) parentJoint = null;
			}

			newJoint = new Joint(newCoords,parentJoint,jointsInOrder[i].name+"_m");
			parentID = -1;
			if (parentJoint != null) parentID = parentJoint.id;
			
			skeleton.addJoint(newJoint,parentID); // Ta dah! :)
			parentList = UpdateParentList (parentList, jointsInOrder[i], newJoint);
			
		}
	}
	return;
}

boolean ConnectToParent(Vec3 newPos,Vec3 oldPos, Vec3 parentPos,int dir, double tol)
{
	boolean conn = false;
	
	if (dir == 0)
		if (Math.abs(newPos.x+oldPos.x-2*parentPos.x) < tol*2) conn = true;
	if (dir == 1)
		if (Math.abs(newPos.y+oldPos.y-2*parentPos.y) < tol*2) conn = true;
	if (dir == 2)
		if (Math.abs(newPos.z+oldPos.z-2*parentPos.z) < tol*2) conn = true;
		
	return conn;
}

// Making sure that a new bone will be connecter to a mirrored parent
// instead of the original one.
Joint[] UpdateParentList(Joint[] list, oldJoint, mirroredJoint)
{
	for (z=0;z<list.length;z++)
		if (list[z] == oldJoint)
			list[z] = mirroredJoint;
	
	return list;
}

// Offset value is used when a partial skeleton is mirrored locally
double setMirrorOffset(boolean byRoot, Joint root, int dir)
{
	offset = 0.0;
		
	p = root.coords.getOrigin();
	if (byRoot)
	{
		if (dir == 0) offset = p.x;
		if (dir == 1) offset = p.y;
		if (dir == 2) offset = p.z;
	}	
	return offset;
}

//*********************************
//    Runnin the script begins here
//*********************************

//get the stuff.....

scene=window.getScene();
sel=scene.getSelection();
selInfo=scene.getObject(sel[0]);
selMesh=selInfo.object;
if (selMesh instanceof Actor) 
{
	selMesh=selMesh.object;
	print("Actor");
}

skeleton=selMesh.getSkeleton();
origJoints=skeleton.getJoints();

roots = Roots(origJoints);
rootNames = RootNames(roots);


// Building dialog components ...

rootNameList=new BComboBox();
for (i=0;i<rootNames.length;i++)
{
	rootNameList.add(rootNames[i]);
}
rootNameList.setSelectedIndex(0);

dirNameList=new BComboBox();
dirNameList.add("X");
dirNameList.add("Y");
dirNameList.add("Z");
dirNameList.setSelectedIndex(0);

onAxisTolField=new ValueField(0.1,ValueField.NONNEGATIVE);

toggleShow = new RadioButtonGroup();
toggleShowGrid = new RowContainer();
showRoots = new BRadioButton ("Roots",true,toggleShow); toggleShowGrid.add(showRoots);
showAll = new BRadioButton ("All",false,toggleShow); toggleShowGrid.add(showAll);

toggleCoord = new RadioButtonGroup();
useOrigin = new BRadioButton ("Origin",true,toggleCoord);
useRoot = new BRadioButton ("Starting point",false,toggleCoord);
toggleCoordGrid = new ColumnContainer();
toggleCoordGrid.add(useOrigin); toggleCoordGrid.add(useRoot);

toggleAction = new RadioButtonGroup();
mirrorAll = new BRadioButton ("All joints",true,toggleAction);//mirrorAll.setEnabled(false);
mirrorSelected = new BRadioButton ("From starting point on",false,toggleAction);//mirrorSelected.setEnabled(false);
//toggleActionGrid = new RowContainer();
toggleActionGrid = new ColumnContainer();
toggleActionGrid.add(mirrorAll);
toggleActionGrid.add(mirrorSelected);

layoutInfo = new LayoutInfo(LayoutInfo.NORTHWEST,LayoutInfo.NONE);
toggleActionGrid.setDefaultLayout(layoutInfo);
toggleCoordGrid.setDefaultLayout(layoutInfo);

comp  = new Widget[]{toggleShowGrid,rootNameList,dirNameList,onAxisTolField,toggleCoordGrid,toggleActionGrid};
labels= new String[]{"Show","Select starting point","Mirror Direction:","On-Axis Tolerance","Mirror about:","What to mirror:"};

// Adding event links to watch over the selection box content.
// Building the event links makes the script slow to start up.

showRoots.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState() == true)
	{
		rootNameList.removeAll();
		for (i=0;i<rootNames.length;i++)
		{
			rootNameList.add(rootNames[i]);
		}
		rootNameList.setSelectedIndex(0);

	}
} 
});

showAll.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState() == true)
	{
		rootNameList.removeAll();
		for (i=0;i<origJoints.length;i++)
		{
			rootNameList.add(origJoints[i].name);
		}
		rootNameList.setSelectedIndex(0);
	}
} 
});

// Launch the dialog .........

dlg=new ComponentsDialog(window,"Mirror Skeleton of \""+selInfo.getName()+"\"" ,comp,labels);

if (!dlg.clickedOk())
	return;

//-----------------------------------------
// When OK is pressed the followong happens
//-----------------------------------------

tolerance = onAxisTolField.getValue();
dirnumber = dirNameList.getSelectedIndex();

if (showAll.getState()) startingJoint = origJoints[rootNameList.getSelectedIndex()];
if (showRoots.getState()) startingJoint = roots[rootNameList.getSelectedIndex()];

mOffset = setMirrorOffset(useRoot.getState(), startingJoint,dirnumber);

workingOrder = new Joint[0];

if (mirrorSelected.getState())
	workingOrder = AddJointWithChildren(startingJoint, workingOrder);

if (mirrorAll.getState())
{
	int r;
	for (r=0;r<roots.length;r++)
		workingOrder = AddJointWithChildren(roots[r], workingOrder);
}

parentList = ParentList(workingOrder);
parentIndexList = ParentIndexes(workingOrder);
mirroringList = MirroringList(workingOrder, dirnumber, tolerance, mOffset, parentIndexList);

MirrorJoints(workingOrder, mirroringList, parentIndexList, parentList, dirnumber, tolerance, mOffset, skeleton);

// On a plugin these would not be useful ---->
m = skeleton.getJoints().length - origJoints.length;
print ("Mirrored "+m+" joints of "+origJoints.length+".");
print ("Joint count of " + selInfo.getName() +" is now "+skeleton.getJoints().length+".");
// <--------

return;