//=====================================================================
//	SCRIPT:                         drago_bsExtractSelected
//	AUTHOR: 			Drago Avdalovic
//	DATE:					Dec 10, 2006
//	PROCEDURE:		drago_bsExtractSelected (global)
//	ARGUEMENTS:		no arguments
//	DESCRIPTION:            spits selected target shapes
//      
//      USAGE:                  select bs geo, select blendShape node in channel box, select name of the of the target-s and run the script
//      RETURN:                 string array with spited targets
//======================================================================
//------------ update:Mar. 28/2007---added turning off and on deformers and polyAverage nodes


global proc string[] drago_bsExtractSelected()
{		
		
       $objList = `channelBox -q -hol mainChannelBox`;
       string $obj[] = `ls -sl -type transform`;
       string $bs[] = `ls -type blendShape $objList`;
       string $BS=$bs[0]; //--------- main blendShape
       string $conns[];  //--------- names of drivers conections
	   string $dup[];
       string $namesBS[]=`drago_namesBS $BS`;
       int $indexBS[]=`drago_indexBS $BS`;
       string $tarSel[] = `channelBox -q -selectedHistoryAttributes mainChannelBox`;
	   string $lockedAttr[]; //-----names of the locked attr
	   float $valLocked[]; // ------value of the locked attr
       setAttr ($BS + ".envelope") 1;
       int $j=0;

       for ($s=0; `size($tarSel)` >= $s; $s++)
			{
				if (`objExists($tarSel[$s])`!=0)
                error ("Object with the name - "+$tarSel[$s]+" - exists in the scene already!");
            }

	   string $hist[]=`listHistory $obj[0]`;
	   string $skinCluster[]=`ls -type skinCluster $hist`;
//-- turn off polyAverageVertex nodes if exists/disconnect them if connected
	   string $pav[]=`ls -type polyAverageVertex $hist`;
	   int $pavValues[];
	   string $pavConnections[];
	   for ($k=0; $k<size($pav); $k++)
	   {
	   		if (`objExists $pav[$k]`)
			{
				if (`connectionInfo -id ($pav[$k]+".iterations")`)
				{
					$pavConnections[$k]=bs_stringFirst(`listConnections -p 1 -s 1 -d 0 ($pav[$k]+".iterations")`);
					disconnectAttr ($pavConnections[$k]) ($pav[$k]+".iterations");
					setAttr ($pav[$k]+".iterations") 0;
					print ("\nDisconnecting : "+$pavConnections[$k]+" -> "+$pav[$k]+".iterations ...\n");
				}
				else
				{
					$pavValues[$k]=`getAttr ($pav[$k]+".iterations")`;
					$pavConnections[$k]="";
					setAttr ($pav[$k]+".iterations") 0;
				}
			}
		}
//-- check for future deformers and turn their envelope to 0	   
		string $futureDeformers[]=bs_deformersPastFutureByName ($obj[0], $BS,1);
		
		if (size($futureDeformers)>0)
		{
			for ($deformer in $futureDeformers)
			{
			   if (`objExists $deformer`)
			   {
					setAttr ($deformer + ".envelope") 0;
					print ("\nSetting envelope : "+$deformer+" .envelope to 0 ...\n");
			   }
			}
		}
//----------- disconnect shapes from driver and unlock locked attr
		int $f=0;
       for ($each in $namesBS)
       {
	   		if (`getAttr -lock ($BS + "." + $each)`)
			{
				$valLocked[$f]=`getAttr ($BS + "." + $each)`;
				setAttr -lock false ($BS + "." + $each);
				$lockedAttr[$f]=($BS + "." + $each );
				$f++;
			}
	      		
       		string $connsTemp[] = `listConnections -scn 1 -s 1 -d 0 -p 1 ($BS + "." + $each)`;
       		$conns[$j] = $connsTemp[0];
	   		
			if (`objExists $conns[$j]`)
	   		{
       			disconnectAttr ($conns[$j]) ($BS + "." + $each);	   
	   		}
			setAttr ($BS + "." + $each) 0;
       		$j++;
       }
//------------ duplicate selected shapes only
       for ($name in $tarSel)
		{
              for($i=0; $i<size($namesBS);$i++)
              {
                 if ($name==$namesBS[$i])
                 {
                	  setAttr ($BS + "." + $namesBS[$i]) 1;
                	  string $dupTemp[] = `duplicate -n $namesBS[$i] $obj[0]`;
					  //$dup[size($dup)]=	$dupTemp[0];

					  connectAttr -f ($dupTemp[0] + ".worldMesh[0]") ($BS + ".inputTarget[0].inputTargetGroup[" + $indexBS[$i] + "].inputTargetItem[6000].inputGeomTarget");
					  setAttr ($BS + "." + $namesBS[$i]) 0;
                  }
              }
		}
//--------- reconnect shapes
       int $k=0;
        for ($each in $namesBS)
       	{	   
	   		if (`objExists $conns[$k]`)
	   		{
				connectAttr ($conns[$k]) ($BS + "." + $each);;
	   		}
       		$k++;
       	}
//-------- sets the original values for the locked shapes and locks them

		for ($g=0; $g<size($lockedAttr); $g++)
		{
			setAttr $lockedAttr[$g] $valLocked[$g];
			setAttr -lock true $lockedAttr[$g];		
		}
		
//---- reconnect polyAverage nodes if connected or assign value they had
		for ($i=0; $i<size($pav); $i++)
	   	{
	   		if (`objExists $pav[$i]`)
			{
				if (`objExists $pavConnections[$i]`)
				{
					connectAttr -f ($pavConnections[$i]) ($pav[$i]+".iterations");
					print ("\nRecconecting :"+ $pavConnections[$i] +" -> "+$pav[$i]+".iterations\n");
				}
				else
				{
					setAttr ($pav[$i]+".iterations") $pavValues[$i];
				}
			}
		}
		
		if (size($futureDeformers)>0)
		{
			for ($deformer in $futureDeformers)
			{
			   if (`objExists $deformer`)
			   {
	   				setAttr ($deformer + ".envelope") 1;
					print ("\nSetting envelope : "+$deformer+" .envelope to 1 ...\n");
			   }
			}
		}
		
return $dup;
}

// extracts name of the target shape
//-------- argument: blend shape name
//-------- retutns string array of the target index

global proc string[] drago_namesBS(string $BS)
{
string $namesBS[];
int $j=0;
string $al[]=`aliasAttr -q $BS`;

	for ($i=0; $i<size($al);$i+=2)
	{
		$namesBS[$j]=$al[$i];
		//print ("Name_" + $j + ": " + $namesBS[$j] + "\n");
		$j++;
	}
return $namesBS;
}
// extracts index number of the target shape
//-------- argument: blend shape name
//-------- retutns integer array of the target index

global proc int[] drago_indexBS(string $BS)
{
int $indexBS[];
int $j=0;
string $al[]=`aliasAttr -q $BS`;
	for ($i=1; $i<size($al);$i+=2)
	{
		string $buffer[];
 		$numTokens = `tokenize $al[$i] "[]" $buffer`;
		$indexBS[$j]=$buffer[1];
	//print ("Index_" + $j + ": " + $indexBS[$j] + "\n");
		$j++;
	}
return $indexBS;
}
global proc string bs_stringFirst(string $array[])
{
	return $array[0];
}

//--$defType[] -> "tweak", "skinCluster", "blendShape", "ffd", "cluster", "cMuscleSystem", etc...
// returns names of requested deformers in the same order as array $defType 
global proc string[] bs_deformersReturnDeformersNames(string $node, string $defType[])
{
	string $defTypeNames[];
	string $allDeformers[]=ls("-type", "geometryFilter",`listHistory -bf -il 1 -gl 1 -pdo 1 $node`);

	for($i=0; $i<size($allDeformers); $i++)
	{
		if(`attributeExists "envelope" $allDeformers[$i]`)
		{
			for ($j=0; $j<size($defType); $j++)
			
			if(`nodeType $allDeformers[$i]`==$defType[$j])
			{
				$defTypeNames[$j]=$allDeformers[$i];			
			}
		}
	}
	return $defTypeNames;
}
//-- returns past/future deformers based on name of deformer 
//-- bs_deformersPastFutureByName wolfman_faceShapes_GEO facialShapes_BS 1 -will return all future deformers from facialShapes_BS
global proc string[] bs_deformersPastFutureByName(string $node, string $fromDeformer, int $pastFuture)
{

  	string $futureDeformers[];
	string $allDeformers[];
	int $parallerBlenderExists=0;
	int $index;
		if (!$pastFuture)
		{
			$allDeformers=ls("-type", "geometryFilter",`listHistory -bf -il 1 -gl 1 -pdo 1 $node`);
		}
		else
		{
			$allDeformers=bs_reverseStringArray (ls("-type", "geometryFilter",`listHistory -bf -il 1 -gl 1 -pdo 1 $node`));
		}
	//-- check for parallel blender
		for ($i=0; $i<size($allDeformers); $i++)
		{
			if ($allDeformers[$i]=="parallelBlender")
			{
				$parallerBlenderExists=1;
			}
			if ($allDeformers[$i]==$fromDeformer)
			{
				$index=$i;
			}
		}
	
	for ($j=$index+1; $j<size($allDeformers); $j++)
	{
		if ($allDeformers[$j]=="parallelBlender" ) //--- exclude parallel blender
		{
			print ("\nSkipping -> "+$allDeformers[$j]+" ...");
		}
		else
		{
			$futureDeformers[size($futureDeformers)] = $allDeformers[$j];
		}
	}
	return $futureDeformers;
}
global proc string[] bs_reverseStringArray(string $passed[])
{
	int $size = `size($passed)`;
	string $return[] = {""};
	int $j = ($size-1);
	for($i=0 ; $i<$size ; $i++)
	{
		$return[$j--] = $passed[$i];
	}
	return $return;
}