1721 lines
41 KiB
Plaintext
1721 lines
41 KiB
Plaintext
/*
|
|
This script contains procedures that supports command button codes in picker.
|
|
It will be auto-source when MG-Picker Studio tool loads.
|
|
*/
|
|
//substitute wrappers--------------------
|
|
global proc string MGP_substitute(string $repExp, string $origString, string $repStr)
|
|
{
|
|
if(catch (`substitute $repExp $origString $repStr`))
|
|
{
|
|
print "\n";
|
|
return $origString;
|
|
}
|
|
return `substitute $repExp $origString $repStr`;
|
|
}
|
|
|
|
//go to indexed panel-----------------------------------------------
|
|
global proc MGP_GoToPanel(int $index)
|
|
{
|
|
MGPickerView -e -activePanelIndex $index;
|
|
}
|
|
//get current picker path/dirs-------------------------------------------
|
|
global proc string MGP_GetCurrentPickerFileOrNode()
|
|
{
|
|
return `MGPickerView -q -pickerFilePath`;
|
|
}
|
|
global proc string MGP_GetCurrentPickerDirectory()
|
|
{
|
|
string $path = `MGPickerView -q -pickerDirPath`;
|
|
if(size($path))
|
|
{
|
|
if(!`endsWith $path "/"`)
|
|
{
|
|
$path += "/";
|
|
}
|
|
}
|
|
return $path;
|
|
}
|
|
|
|
//get current mouse interacting picker item ---------------
|
|
global proc string MGP_GetCurrentInteractiveItem()
|
|
{
|
|
return `MGPicker -q -currentItem`;
|
|
}
|
|
|
|
// get keyboard modifiers-----------------
|
|
global proc int[] MGP_GetKeyboardModifiers()
|
|
//0 control
|
|
//1 shift
|
|
//2 alt
|
|
{
|
|
int $keyMods[];
|
|
int $mods = `getModifiers`;
|
|
if (($mods / 4) % 2)
|
|
{
|
|
$keyMods[0]=1;
|
|
}
|
|
else
|
|
{
|
|
$keyMods[0]=0;
|
|
}
|
|
if (($mods / 1) % 2)
|
|
{
|
|
$keyMods[1]=1;
|
|
}
|
|
else
|
|
{
|
|
$keyMods[1]=0;
|
|
}
|
|
if (($mods / 8) % 2)
|
|
{
|
|
$keyMods[2]=1;
|
|
}
|
|
else
|
|
{
|
|
$keyMods[2]=0;
|
|
}
|
|
return $keyMods;
|
|
}
|
|
//set/get namespace-----------------------------------------
|
|
global proc string MGP_GetCurrentPickerNamespace()
|
|
{
|
|
return `MGPickerView -q -namespace`;
|
|
}
|
|
global proc string MGP_GetNamespaceViaObj(string $node)
|
|
{
|
|
return `MGPickerService -q -namespace $node`;
|
|
}
|
|
global proc int MGP_SetCurrentPickerNamespace(string $newNamespace)
|
|
{
|
|
return `MGPickerView -e -namespace $newNamespace`;
|
|
}
|
|
global proc MGP_SetCurrentPickerNamespace_WithUI()
|
|
{
|
|
MGPicker -e -popupNamespace;
|
|
}
|
|
proc string mgp_removeNamespace(string $obj)
|
|
{
|
|
string $cTemp[] = `stringToStringArray $obj ":"`;
|
|
if(size($cTemp)==1)
|
|
{
|
|
return $obj;
|
|
}
|
|
string $temp[] =`stringToStringArray $obj "|"`;
|
|
string $resultList[];clear $resultList;
|
|
string $result;
|
|
for($each in $temp)
|
|
{
|
|
string $cTemp[] = `stringToStringArray $each ":"`;
|
|
$resultList[size($resultList)] = $cTemp[size($cTemp)-1];
|
|
}
|
|
return `stringArrayToString $resultList "|"`;
|
|
}
|
|
proc string mgp_addNsToObj(string $ns, string $obj)
|
|
{
|
|
//if namespace is empty:
|
|
$ns = strip($ns);
|
|
$obj = strip($obj);
|
|
if(!size($ns))
|
|
{
|
|
return $obj;
|
|
}
|
|
if(!size($obj))
|
|
{
|
|
return "";
|
|
}
|
|
|
|
//if already contains namespace, do not add again:
|
|
string $temp[]=`stringToStringArray $obj ":"`;
|
|
if(size($temp) >= 2)
|
|
{
|
|
return $obj;
|
|
}
|
|
//add namespace:
|
|
clear $temp;
|
|
$temp=`stringToStringArray $obj "|"`;
|
|
string $result;
|
|
int $len = size($temp);
|
|
if($len == 1)
|
|
{
|
|
return ($ns+":"+$obj);
|
|
}
|
|
for($i=0;$i<$len; $i++)
|
|
{
|
|
$temp[$i] =($ns+":"+$temp[$i]);
|
|
}
|
|
return `stringArrayToString $temp "|"`;
|
|
}
|
|
//eval selection buttons-----------------------------------------
|
|
global proc MGP_EvalPanelAllSelectButtons(int $mode)
|
|
//$mode 0: replace selection
|
|
//$mode 1: add to selection
|
|
//$mode 2: remove from selection
|
|
//$mode 3: invert selection
|
|
{
|
|
MGPickerView -e -selectPanelButtons $mode;
|
|
}
|
|
global proc MGP_EvalPanelAllSelectButtons_viaPanelIndex(int $mode, int $index)
|
|
//$mode 0: replace selection
|
|
//$mode 1: add to selection
|
|
//$mode 2: remove from selection
|
|
//$mode 3: invert selection
|
|
{
|
|
MGPickerView -e -selectPanelIndexButtons $mode $index;
|
|
}
|
|
global proc MGP_EvalPickerAllSelectButtons(int $mode)
|
|
//$mode 0: replace selection
|
|
//$mode 1: add to selection
|
|
//$mode 2: remove from selection
|
|
//$mode 3: invert selection
|
|
{
|
|
MGPickerView -e -selectPickerButtons $mode;
|
|
}
|
|
|
|
global proc MGP_MirrorSelection(int $mode)
|
|
//$mode 0: replace selection
|
|
//$mode 1: add to selection
|
|
{
|
|
MGPickerView -e -mirrorSelection $mode;
|
|
}
|
|
global proc MGP_SelectControlsWithPickerNamespace_Ex(string $controls[])
|
|
{
|
|
int $modifiers[] = `MGP_GetKeyboardModifiers`;
|
|
int $control = $modifiers[0];
|
|
int $shift = $modifiers[1];
|
|
int $controlShift = ($control && $shift);
|
|
int $keyMods = 0;
|
|
if($controlShift)
|
|
{
|
|
$keyMods = 1;
|
|
}
|
|
else if($control)
|
|
{
|
|
$keyMods = 2;
|
|
}
|
|
else if($shift)
|
|
{
|
|
$keyMods = 3;
|
|
}
|
|
MGP_SelectControlsWithPickerNamespace $keyMods $controls;
|
|
}
|
|
global proc MGP_SelectControlsWithPickerNamespace(int $mode, string $controls[])
|
|
//$mode 0: select objects
|
|
//$mode 1: add select objects
|
|
//$mode 2: deselect objects
|
|
//$mode 3: invert select objects
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
|
|
string $existedControls[];
|
|
clear $existedControls;
|
|
int $existCount = 0;
|
|
int $noExistCount = 0;
|
|
for($obj in $controls)
|
|
{
|
|
string $nsObj = `mgp_addNsToObj $ns $obj`;
|
|
if(`objExists $nsObj`)
|
|
{
|
|
$existedControls[size($existedControls)] = $nsObj;
|
|
$existCount ++;
|
|
}
|
|
else
|
|
{
|
|
MGP_ScriptEditorFeedback ("Object does not exist: "+$nsObj) 1;
|
|
$noExistCount ++;
|
|
}
|
|
}
|
|
if($existCount)
|
|
{
|
|
if(!$mode)
|
|
{
|
|
select $existedControls;
|
|
}
|
|
else if($mode == 1)
|
|
{
|
|
select -add $existedControls;
|
|
}
|
|
else if($mode == 2)
|
|
{
|
|
select -d $existedControls;
|
|
}
|
|
else if($mode == 3)
|
|
{
|
|
select -tgl $existedControls;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!$mode)
|
|
{
|
|
select -cl;
|
|
}
|
|
}
|
|
string $rep = $existCount + " objects selected. ";
|
|
if($noExistCount)
|
|
{
|
|
$rep += ($noExistCount +" are not exists thus ignored.");
|
|
}
|
|
MGP_ScriptEditorFeedback $rep 0;
|
|
}
|
|
//get current interacted attribute buttons-----------------------------------------
|
|
global proc string MGP_GetCurrentAttributeButton_Attribute(int $includeNamespace)
|
|
//$includeNamespace 0 for no namespace
|
|
//$includeNamespace 1 for has namespace.
|
|
{
|
|
return `MGPicker -q -currentAttributeName $includeNamespace`;
|
|
}
|
|
global proc MGP_SelectAll_viaCurrentPicker_Ex()
|
|
{
|
|
int $modifiers[] = `MGP_GetKeyboardModifiers`;
|
|
int $control = $modifiers[0];
|
|
int $shift = $modifiers[1];
|
|
int $controlShift = ($control && $shift);
|
|
int $mode = 0;
|
|
if($controlShift)
|
|
{
|
|
$mode = 1;
|
|
}
|
|
else if($control)
|
|
{
|
|
$mode = 2;
|
|
}
|
|
else if($shift)
|
|
{
|
|
$mode = 3;
|
|
}
|
|
MGP_EvalPickerAllSelectButtons $mode;
|
|
}
|
|
global proc MGP_SelectAll_viaCurrentPanel_Ex()
|
|
{
|
|
int $modifiers[] = `MGP_GetKeyboardModifiers`;
|
|
int $control = $modifiers[0];
|
|
int $shift = $modifiers[1];
|
|
int $controlShift = ($control && $shift);
|
|
int $mode = 0;
|
|
if($controlShift)
|
|
{
|
|
$mode = 1;
|
|
}
|
|
else if($control)
|
|
{
|
|
$mode = 2;
|
|
}
|
|
else if($shift)
|
|
{
|
|
$mode = 3;
|
|
}
|
|
MGP_EvalPanelAllSelectButtons $mode;
|
|
}
|
|
global proc MGP_MirrorSelectViaPanel_Ex()
|
|
{
|
|
int $modifiers[] = `MGP_GetKeyboardModifiers`;
|
|
int $control = $modifiers[0];
|
|
int $shift = $modifiers[1];
|
|
int $controlShift = ($control && $shift);
|
|
int $mode = 0;
|
|
if($controlShift)
|
|
{
|
|
$mode = 1;
|
|
}
|
|
MGP_MirrorSelection $mode;
|
|
}
|
|
//isolation -----------------------------------------
|
|
global proc MGP_IsolateSelectedRig()
|
|
{
|
|
string $activePanel = `getPanel -withFocus`;
|
|
MGP_IsolateSelectedRig_doit $activePanel;
|
|
}
|
|
global proc MGP_IsolateSelectedObjects()
|
|
{
|
|
string $activePanel = `getPanel -withFocus`;
|
|
MGP_IsolateSelection_doit $activePanel;
|
|
}
|
|
global proc MGP_CancelIsolation()
|
|
{
|
|
string $activePanel = `getPanel -withFocus`;
|
|
MGP_CancelIsolation_doit $activePanel;
|
|
}
|
|
|
|
//keyframing -----------------------------------------
|
|
global proc MGP_SetKeyframeEachKeyOrGap(int $mode)
|
|
{
|
|
//mode 0: key each key
|
|
//mode 1: key each certain frame
|
|
string $sel[]=`ls -sl`;
|
|
if(!size($sel))
|
|
{
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.noSel.war"` 1;
|
|
return;
|
|
}
|
|
//selectKey -clear ;
|
|
global string $gPlayBackSlider;
|
|
string $selectrange = `timeControl -q -range $gPlayBackSlider`;
|
|
float $selectrangeArray []= `timeControl -q -rangeArray $gPlayBackSlider`;
|
|
int $selROrNot=`timeControl -q -rangeVisible $gPlayBackSlider`;
|
|
|
|
string $defaultItts[] = `keyTangent -q -global -itt`;
|
|
string $defaultOtts[] = `keyTangent -q -global -ott`;
|
|
string $defaultItt = $defaultItts[0];
|
|
string $defaultOtt = $defaultOtts[0];
|
|
if(!$mode)
|
|
{
|
|
float $cTime = `currentTime -q`;
|
|
//string $sel[]=`ls -sl`;
|
|
float $ticks[]=`keyframe -q -tc $sel`;
|
|
string $tickstring[];clear $tickstring;
|
|
for ($each in $ticks)
|
|
{
|
|
$tickstring[size($tickstring)]=$each;
|
|
}
|
|
$tickstring=stringArrayRemoveDuplicates($tickstring);
|
|
string $keyframes[];clear $keyframes;
|
|
for ($i=0;$i<size($tickstring);$i++)
|
|
{
|
|
float $ct=$tickstring[$i];
|
|
//if(size(`keyframe -q -tc $eachS`))
|
|
//{
|
|
if(!$i)
|
|
currentTime $ct;
|
|
//}
|
|
//dgeval $sel;
|
|
if($selROrNot)
|
|
{
|
|
if($ct>=$selectrangeArray[0]&&$ct<=$selectrangeArray[1])
|
|
{
|
|
if(!$i)
|
|
{
|
|
setKeyframe -time $ct;
|
|
$keyframes = `keyframe -q -n $sel`;
|
|
}
|
|
else
|
|
{
|
|
if(size($keyframes))
|
|
setKeyframe -insert -t $ct $keyframes;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!$i)
|
|
{
|
|
setKeyframe -time $ct;
|
|
$keyframes = `keyframe -q -n $sel`;
|
|
}
|
|
else
|
|
{
|
|
if(size($keyframes))
|
|
setKeyframe -insert -t $ct $keyframes;
|
|
}
|
|
}
|
|
keyTangent -t $ct -itt $defaultItt -ott $defaultOtt $keyframes;
|
|
}
|
|
currentTime $cTime;
|
|
}
|
|
else
|
|
{
|
|
promptDialog -title `MGP_MultiLanguage "pkr.app"`
|
|
-m `MGP_MultiLanguage "pkr.serv.inputFrameCount.prompt"`
|
|
-button "OK";
|
|
int $gap=`promptDialog -q -text`;
|
|
if($gap <= 0)
|
|
{
|
|
return;
|
|
}
|
|
int $cTime=`currentTime -q`;
|
|
int $start=`playbackOptions -q -minTime`;
|
|
int $end=`playbackOptions -q -max`;
|
|
string $keyframes[];clear $keyframes;
|
|
if($selROrNot)
|
|
{
|
|
$cTime=$selectrangeArray[0];
|
|
$start=$cTime;
|
|
$end=$selectrangeArray[1];
|
|
}
|
|
if($cTime>$end||$cTime<$start)
|
|
{
|
|
for ($i=$start;$i<$end;$i+=$gap)
|
|
{
|
|
if($i==$start)
|
|
{
|
|
setKeyframe -time $i;
|
|
$keyframes = `keyframe -q -n $sel`;
|
|
}
|
|
else
|
|
{
|
|
if(size($keyframes))
|
|
setKeyframe -insert -t $i $keyframes;
|
|
}
|
|
keyTangent -t $i -itt $defaultItt -ott $defaultOtt $keyframes;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ($i=$cTime;$i<=$end;$i+=$gap)
|
|
{
|
|
if($i==$cTime)
|
|
{
|
|
setKeyframe -time $i;
|
|
$keyframes = `keyframe -q -n $sel`;
|
|
}
|
|
else
|
|
{
|
|
if(size($keyframes))
|
|
setKeyframe -insert -t $i $keyframes;
|
|
}
|
|
keyTangent -t $i -itt $defaultItt -ott $defaultOtt $keyframes;
|
|
|
|
//setKeyframe -time $i;
|
|
}
|
|
for ($i=$cTime;$i>=$start;$i-=$gap)
|
|
{
|
|
if(size($keyframes))
|
|
{
|
|
setKeyframe -insert -t $i $keyframes;
|
|
keyTangent -t $i -itt $defaultItt -ott $defaultOtt $keyframes;
|
|
}
|
|
//setKeyframe -time $i;
|
|
}
|
|
}
|
|
}
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.jobDone"` 0;
|
|
}
|
|
proc int mgp_setKeyframeWithExistTangent_doit(float $t,string $anNodes[], int $ignoreExistKey)
|
|
{
|
|
int $newKeyCount = 0;
|
|
int $doSetKey = 1;
|
|
for($each in $anNodes)
|
|
{
|
|
$doSetKey = 1;
|
|
if($ignoreExistKey)
|
|
{
|
|
float $hasKeyframe[]= `keyframe -t $t -q $each`;
|
|
if(size($hasKeyframe))
|
|
{
|
|
$doSetKey = 0;
|
|
}
|
|
}
|
|
float $lastKey = `findKeyframe -which "previous" -t $t $each`;
|
|
string $itt[] = `keyTangent -t $lastKey -q -inTangentType $each`;
|
|
string $ott[] = `keyTangent -t $lastKey -q -outTangentType $each`;
|
|
|
|
if($doSetKey)
|
|
{
|
|
setKeyframe -t $t $each;
|
|
keyTangent -t $t -inTangentType $itt[0] -outTangentType $ott[0] $each;
|
|
$newKeyCount ++;
|
|
}
|
|
}
|
|
return $newKeyCount;
|
|
}
|
|
global proc int MGP_SetKeyframeForOnlyKeyframed()
|
|
{
|
|
string $sel[]=`ls -sl`;
|
|
if(!size($sel))
|
|
{
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.noSel.war"` 1;
|
|
return 0;
|
|
}
|
|
string $ans[] = `keyframe -q -name $sel`;
|
|
if(!size($ans))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
float $t = `currentTime -q`;
|
|
return `mgp_setKeyframeWithExistTangent_doit $t $ans 1`;
|
|
}
|
|
global proc MG_SetKeyframeNonDefaultChannels ()
|
|
{
|
|
string $sel[]=`ls -sl`;
|
|
if(!size($sel))
|
|
{
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.noSel.war"` 1;
|
|
return;
|
|
}
|
|
string $defaultItts[] = `keyTangent -q -global -itt`;
|
|
string $defaultOtts[] = `keyTangent -q -global -ott`;
|
|
string $defaultItt = $defaultItts[0];
|
|
string $defaultOtt = $defaultOtts[0];
|
|
float $ct = `currentTime -q`;
|
|
for ($each in $sel)
|
|
{
|
|
string $rawAttrs[]=`listAttr -k -scalar $each`;
|
|
string $targetAttr[];clear $targetAttr;
|
|
for ($eachA in $rawAttrs)
|
|
{
|
|
string $temp[]=`keyframe -at $eachA -q -name $each`;
|
|
if(!size($temp))
|
|
{
|
|
float $defaultV[]=`attributeQuery -n $each -listDefault $eachA`;
|
|
float $cV=`getAttr ($each+"."+$eachA)`;
|
|
if($defaultV[0]!=$cV)
|
|
{
|
|
setKeyframe -at $eachA $each;
|
|
$keyframes = `keyframe -q -n $each`;
|
|
keyTangent -t $ct -itt $defaultItt -ott $defaultOtt $keyframes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.jobDone"` 0;
|
|
}
|
|
|
|
global proc MGP_KeyframeCurrentPanel()
|
|
{
|
|
MGP_EvalPanelAllSelectButtons 0;
|
|
if(size(`ls -sl`))
|
|
{
|
|
setKeyframe;
|
|
}
|
|
}
|
|
global proc MGP_KeyframeCurrentPicker()
|
|
{
|
|
MGP_EvalPickerAllSelectButtons 0;
|
|
if(size(`ls -sl`))
|
|
{
|
|
setKeyframe;
|
|
}
|
|
}
|
|
//update picker via maya scene-------------------------------
|
|
global proc MGP_UpdatePickerItems()
|
|
{
|
|
MGPickerView -e -syncPickerValue;
|
|
}
|
|
//reset attributes -----------------------------------------
|
|
global proc MGP_ResetTransform_ViaSelection (int $mode)
|
|
//$mode 0: for reseting translation
|
|
//$mode 1: for reseting rotatation
|
|
//$mode 2: for reseting scale.
|
|
{
|
|
string $nodes[]= `ls -sl`;
|
|
MGP_ResetTransform_ViaList($nodes,$mode);
|
|
}
|
|
global proc MGP_ResetTransform_ViaList (string $nodes[],int $mode)
|
|
//$mode 0: for reseting translation
|
|
//$mode 1: for reseting rotatation
|
|
//$mode 2: for reseting scale.
|
|
{
|
|
int $number = size($nodes);
|
|
if (!$number)
|
|
{
|
|
string $msg = `MGP_MultiLanguage "pkr.noSel.war"`;
|
|
MGP_ScriptEditorFeedback $msg 1;
|
|
}
|
|
else
|
|
{
|
|
string $attrPrefix = "translate";
|
|
int $defaultV = 0;
|
|
if($mode == 1)
|
|
{
|
|
$attrPrefix = "rotate";
|
|
}
|
|
else if($mode == 2)
|
|
{
|
|
$attrPrefix = "scale";
|
|
$defaultV = 1;
|
|
}
|
|
int $count = 0;
|
|
int $reseted;
|
|
for ($i=0; $i<size ($nodes);$i++ )
|
|
{
|
|
$reseted = 0;
|
|
if (`getAttr -se ($nodes[$i]+"."+$attrPrefix+"X")` ==1)
|
|
{
|
|
setAttr ($nodes[$i] +"."+$attrPrefix+"X") $defaultV;
|
|
$reseted = 1;
|
|
}
|
|
if (`getAttr -se ($nodes[$i]+"."+$attrPrefix+"Y")` ==1)
|
|
{
|
|
setAttr ($nodes[$i] +"."+$attrPrefix+"Y") $defaultV;
|
|
$reseted = 1;
|
|
}
|
|
if (`getAttr -se ($nodes[$i]+"."+$attrPrefix+"Z")` ==1)
|
|
{
|
|
setAttr ($nodes[$i] +"."+$attrPrefix+"Z") $defaultV;
|
|
$reseted = 1;
|
|
}
|
|
if($reseted)
|
|
{
|
|
$count++;
|
|
}
|
|
}
|
|
string $countStr = $count;
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage_rep2 "pkr.serv.attrReset.rep" $attrPrefix $countStr` 0;
|
|
MGP_UpdatePickerItems;
|
|
}
|
|
}
|
|
//reset all the keyable attributes of the selection:
|
|
global proc MGP_ResetSelectionAttributes()
|
|
{
|
|
string $sel []=`ls -sl`;
|
|
MGP_ResetObjectsAttributes $sel ;
|
|
}
|
|
global proc MGP_ResetObjectsAttributes(string $nodes[])
|
|
{
|
|
if(!size($nodes))
|
|
{
|
|
string $msg = `MGP_MultiLanguage "pkr.noSel.war"`;
|
|
MGP_ScriptEditorFeedback $msg 1;
|
|
return;
|
|
}
|
|
int $count;
|
|
for($each in $nodes)
|
|
{
|
|
int $reseted =0;
|
|
string $attr []=`listAttr -scalar -channelBox $each`;
|
|
$attr =stringArrayCatenate ($attr,`listAttr -scalar -k $each`);
|
|
for ($eachA in $attr)
|
|
{
|
|
string $theAttr = ($each+"."+$eachA);
|
|
if(!`getAttr -l $theAttr`)
|
|
{
|
|
$reseted =1;
|
|
int $rangeExist =`attributeQuery -rangeExists -n $each $eachA`;
|
|
float $defaultInt[]=`attributeQuery -n $each -ld $eachA`;
|
|
float $value = $defaultInt[0];
|
|
if($rangeExist)
|
|
{
|
|
float $ranges[]=` attributeQuery -range -n $each $eachA`;
|
|
if($value>$ranges[1])$value=$ranges[1];
|
|
if($value<$ranges[0])$value=$ranges[0];
|
|
}
|
|
|
|
catch(`setAttr $theAttr $value`);
|
|
}
|
|
}
|
|
if($reseted)
|
|
{
|
|
$count++;
|
|
}
|
|
}
|
|
if($count)
|
|
{
|
|
MGP_UpdatePickerItems;
|
|
}
|
|
string $countStr = $count;
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage_rep1 "pkr.serv.objChannelReset" $countStr` 0;
|
|
}
|
|
|
|
|
|
//Apply Pose -----------------------------------------
|
|
|
|
proc mgp_applyPoseValue_doit(string $objDotAttr, float $targetValue, float $percentage)
|
|
{
|
|
float $currentValue = `getAttr $objDotAttr`;
|
|
float $gap = $targetValue - $currentValue;
|
|
if(!$gap)
|
|
{
|
|
return;
|
|
}
|
|
$gap *= $percentage;
|
|
$currentValue += $gap;
|
|
setAttr $objDotAttr $currentValue;
|
|
}
|
|
proc MGP_ApplyPose_doit(int $mode, string $ns, string $poseData[])
|
|
//$mode 0: apply pose to all
|
|
//$mode 1: apply pose only if it is selected.
|
|
//$mode 2: not apply pose if it is selected.
|
|
{
|
|
int $len = size($poseData);
|
|
if(!$len)
|
|
{
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.serv.noPoseToApply"` 1;
|
|
return;
|
|
}
|
|
int $control=0,$shift=0;
|
|
int $modifiers[] = `MGP_GetKeyboardModifiers`;
|
|
$shift=$modifiers[1];
|
|
$control=$modifiers[0];
|
|
|
|
float $percentage = 1;
|
|
if($control)
|
|
{
|
|
$percentage = 0.2;
|
|
}
|
|
if($shift)
|
|
{
|
|
$percentage = 0.5;
|
|
}
|
|
string $temp[];
|
|
string $obj;
|
|
float $currentValue = 0;
|
|
float $targetValue = 0;
|
|
float $valueGap = 0;
|
|
string $rep;
|
|
|
|
string $sel[];
|
|
string $selNoNS[];
|
|
if($mode)
|
|
{
|
|
$sel =`ls -sl`;
|
|
for($obj in $sel)
|
|
{
|
|
$selNoNS[size($selNoNS)] = `mgp_removeNamespace $obj`;
|
|
}
|
|
}
|
|
for($data in $poseData)
|
|
{
|
|
$temp = `stringToStringArray $data "="`;
|
|
if(size($temp) != 2)
|
|
{
|
|
continue;
|
|
}
|
|
$obj = `strip $temp[0]`;
|
|
if(!size($obj))
|
|
{
|
|
continue;
|
|
}
|
|
if($mode)
|
|
{
|
|
//print $selNoNS;
|
|
//print ("\n$obj: "+$obj);
|
|
string $nodeAndAttr[]=`stringToStringArray $obj "."`;
|
|
int $contain = `stringArrayContains $nodeAndAttr[0] $selNoNS`;
|
|
if($mode == 1)
|
|
{
|
|
if(!$contain)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if($mode == 2)
|
|
{
|
|
if($contain)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
$obj = `mgp_addNsToObj $ns $obj`;
|
|
|
|
$targetValue = `strip $temp[1]`;
|
|
if(catch (`mgp_applyPoseValue_doit $obj $targetValue $percentage`))
|
|
{
|
|
$rep = (`MGP_MultiLanguage "pkr.serv.errorSetAttr"`+" "+$obj+" => "+$targetValue);
|
|
if($percentage != 1)
|
|
{
|
|
$rep += (" "+`MGP_MultiLanguage "pkr.serv.withPercentage"`+" "+$percentage);
|
|
}
|
|
$rep += "\n";
|
|
MGP_ScriptEditorFeedback $rep 1;
|
|
continue;
|
|
}
|
|
$rep = (`MGP_MultiLanguage "pkr.serv.doneSetAttr"`+" "+$obj+" => "+$targetValue);
|
|
if($percentage != 1)
|
|
{
|
|
$rep += (" "+`MGP_MultiLanguage "pkr.serv.withPercentage"`+" "+$percentage);
|
|
}
|
|
$rep += "\n";
|
|
MGP_ScriptEditorFeedback $rep 0;
|
|
}
|
|
}
|
|
global proc MGP_ApplyPose(string $poseData[])
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
MGP_ApplyPose_doit 0 $ns $poseData;
|
|
}
|
|
|
|
global proc MGP_ApplyPose_ToSelectedRef(string $poseData [])
|
|
{
|
|
string $sel[]=`ls -sl`;
|
|
string $error = `MGP_MultiLanguage "pkr.noSel.war"`;
|
|
if(!size($sel))
|
|
{
|
|
MGP_ScriptEditorFeedback $error 1;
|
|
return;
|
|
}
|
|
string $ns = `MGP_GetNamespaceViaObj $sel[0]`;
|
|
MGP_ApplyPose_doit 0 $ns $poseData;
|
|
}
|
|
|
|
global proc MGP_ApplyPose_Ex(int $mode, string $poseData[])
|
|
//$mode 1: apply only selected.
|
|
//$mode 2: not apply if selected.
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
MGP_ApplyPose_doit $mode $ns $poseData;
|
|
}
|
|
|
|
global proc MGP_ApplyPoseEx_ToSelectedRef(int $mode, string $poseData [])
|
|
{
|
|
string $sel[]=`ls -sl`;
|
|
string $error = `MGP_MultiLanguage "pkr.noSel.war"`;
|
|
if(!size($sel))
|
|
{
|
|
MGP_ScriptEditorFeedback $error 1;
|
|
return;
|
|
}
|
|
string $ns = `MGP_GetNamespaceViaObj $sel[0]`;
|
|
MGP_ApplyPose_doit $mode $ns $poseData;
|
|
}
|
|
|
|
global proc MGP_SetAttributeViaPickerNamespace(string $objDotAttrWithoutNS, float $value)
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
string $objDotAttr = mgp_addNsToObj($ns, $objDotAttrWithoutNS);
|
|
setAttr $objDotAttr $value;
|
|
}
|
|
global proc float MGP_GetAttributeFloatValue_ViaPickerNamespace(string $objDotAttrWithoutNS)
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
string $objDotAttr = mgp_addNsToObj($ns, $objDotAttrWithoutNS);
|
|
float $v = `getAttr $objDotAttr`;
|
|
return $v;
|
|
}
|
|
global proc float[] MGP_GetAttributeFloatValueArray_ViaPickerNamespace(string $objDotAttrWithoutNS)
|
|
{
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
string $objDotAttr = mgp_addNsToObj($ns, $objDotAttrWithoutNS);
|
|
float $v[] = `getAttr $objDotAttr`;
|
|
return $v;
|
|
}
|
|
proc string[] mgp_getCurrentPoseData_doit(int $includeNS)
|
|
{
|
|
string $sel[]=`ls -sl`;
|
|
if(!size($sel))
|
|
{
|
|
return {};
|
|
}
|
|
string $resultDataList[];
|
|
clear $resultDataList;
|
|
float $cValue = 0;
|
|
string $objDotAttr = "";
|
|
global string $MGP_PoseFeature_EnvolvedControls[];
|
|
clear $MGP_PoseFeature_EnvolvedControls;
|
|
for($each in $sel)
|
|
{
|
|
string $attr []=`listAttr -scalar -channelBox $each`;
|
|
$attr =stringArrayCatenate ($attr,`listAttr -scalar -k $each`);
|
|
int $envolved = 0;
|
|
string $eachWithoutNS = `mgp_removeNamespace $each`;
|
|
for ($eachA in $attr)
|
|
{
|
|
string $theAttr = ($each+"."+$eachA);
|
|
if(!`getAttr -l $theAttr`)
|
|
{
|
|
if(!$includeNS)
|
|
{
|
|
$objDotAttr = ($eachWithoutNS+"."+$eachA);
|
|
}
|
|
else
|
|
{
|
|
$objDotAttr = $theAttr;
|
|
}
|
|
$cValue = `getAttr $theAttr`;
|
|
$resultDataList[size($resultDataList)] = ($objDotAttr +"="+$cValue);
|
|
$envolved = 1;
|
|
}
|
|
}
|
|
if($envolved)
|
|
{
|
|
if(!$includeNS)
|
|
{
|
|
$MGP_PoseFeature_EnvolvedControls[size($MGP_PoseFeature_EnvolvedControls)] = $eachWithoutNS;
|
|
}
|
|
else
|
|
{
|
|
$MGP_PoseFeature_EnvolvedControls[size($MGP_PoseFeature_EnvolvedControls)] = $each;
|
|
}
|
|
}
|
|
}
|
|
return $resultDataList;
|
|
}
|
|
global proc string[] MGP_GetPoseCommandButtonCommandString(int $includeNS)
|
|
{
|
|
string $result[];
|
|
string $data[]=`mgp_getCurrentPoseData_doit $includeNS`;
|
|
if(!size($data))
|
|
{
|
|
return {};
|
|
}
|
|
|
|
string $dataStr = `stringArrayToString $data "\",\n\t\t\""`;
|
|
$result[0] = "Button Command"; //no use,just for the two indice per menu item rule consistancy.
|
|
$result[1] = "MGP_ApplyPose {\""+$dataStr+"\"};";
|
|
|
|
//now for other apply ways:
|
|
global string $MGP_PoseFeature_EnvolvedControls[];
|
|
string $controls = `stringArrayToString $MGP_PoseFeature_EnvolvedControls "\",\n\t\t\""`;
|
|
$result[2] = "Select Pose Controls";
|
|
$result[3] = "MGP_SelectControlsWithPickerNamespace 0 {\""+$controls+"\"};";
|
|
$result[4] = "Apply Only If Selected";
|
|
$result[5] = "MGP_ApplyPose_Ex 1 {\""+$dataStr+"\"};";
|
|
$result[6] = "Not Apply If Selected";
|
|
$result[7] = "MGP_ApplyPose_Ex 2 {\""+$dataStr+"\"};";
|
|
$result[8] = "Apply To Selected Rig";
|
|
$result[9] = "MGP_ApplyPose_ToSelectedRef {\""+$dataStr+"\"};";
|
|
|
|
$result[10] = "Apply To Selected Rig(Only Selected)";
|
|
$result[11] = "MGP_ApplyPoseEx_ToSelectedRef 1 {\""+$dataStr+"\"};";
|
|
$result[12] = "Apply To Selected Rig(Ignore Selected)";
|
|
$result[13] = "MGP_ApplyPoseEx_ToSelectedRef 2 {\""+$dataStr+"\"};";
|
|
$result[14] = ""; //separator.
|
|
$result[15] = ""; //separator.
|
|
$result[16] = "Add Select Pose Controls";
|
|
$result[17] = "MGP_SelectControlsWithPickerNamespace 1 {\""+$controls+"\"};";
|
|
$result[18] = "Deselect Pose Controls";
|
|
$result[19] = "MGP_SelectControlsWithPickerNamespace 2 {\""+$controls+"\"};";
|
|
$result[20] = "Toggle Select Pose Controls";
|
|
$result[21] = "MGP_SelectControlsWithPickerNamespace 3 {\""+$controls+"\"};";
|
|
return $result;
|
|
}
|
|
|
|
//for install picker item to shelf---------------------------------------------
|
|
proc string mgp_activeOrCreateShelfTab(string $tabName)
|
|
{
|
|
global string $gShelfTopLevel;
|
|
string $st =`tabLayout -q -st $gShelfTopLevel`;
|
|
if(!size($tabName))
|
|
{
|
|
return $st;
|
|
}
|
|
string $shelfLayouts []=`tabLayout -q -ca $gShelfTopLevel `;
|
|
if(`stringArrayContains $tabName $shelfLayouts`)
|
|
{
|
|
tabLayout -e -st $tabName $gShelfTopLevel;
|
|
}
|
|
else
|
|
{
|
|
string $sl = `shelfLayout -p $gShelfTopLevel $tabName`;
|
|
tabLayout -e -tabLabel $sl $tabName $gShelfTopLevel;
|
|
tabLayout -e -st $tabName $gShelfTopLevel;
|
|
}
|
|
return $tabName;
|
|
}
|
|
proc string mgp_replaceNamespace(string $obj,string $ns)
|
|
{
|
|
if(size($ns))
|
|
{
|
|
$ns += ":";
|
|
}
|
|
string $temp[]=`stringToStringArray $obj ":"`;
|
|
if(size($temp) > 1)
|
|
{
|
|
string $oldNS = $temp[0]+":";
|
|
return `substituteAllString $obj $oldNS ($ns)`;
|
|
}
|
|
else
|
|
{
|
|
$obj = $ns + $obj;
|
|
}
|
|
return $obj;
|
|
}
|
|
global proc MGP_EvalSelectionEx(string $objs[])
|
|
{
|
|
int $len = size($objs);
|
|
int $control=0,$shift=0,$alt=0;
|
|
//int $caplock=0;
|
|
int $mods[] = `MGP_GetKeyboardModifiers`;
|
|
$control = $mods[0];
|
|
$shift = $mods[1];
|
|
$alt = $mods[2];
|
|
|
|
string $ns = `MGP_getSelectionNamespace`;
|
|
if($alt)
|
|
{
|
|
for($i=0; $i<$len; $i++)
|
|
{
|
|
$objs[$i] = `mgp_replaceNamespace $objs[$i] $ns`;
|
|
}
|
|
}
|
|
//print $objs;
|
|
if(!$control && !$shift)
|
|
{
|
|
select -cl;
|
|
}
|
|
int $selCount = 0;
|
|
for($obj in $objs)
|
|
{
|
|
if(!`objExists $obj`)
|
|
{
|
|
MGP_ScriptEditorFeedback (`MGP_MultiLanguage_rep1 "pkr.serv.objNotExist" $obj`) 0;
|
|
continue;
|
|
}
|
|
$selCount ++;
|
|
if($control)
|
|
{
|
|
if(!$shift)
|
|
{
|
|
select -deselect $obj;
|
|
}
|
|
else
|
|
{
|
|
select -add $obj;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!$shift)
|
|
{
|
|
select -add $obj;
|
|
}
|
|
else
|
|
{
|
|
select -toggle $obj;
|
|
}
|
|
}
|
|
}
|
|
if(!$control && !$shift)
|
|
{
|
|
MGP_ScriptEditorFeedback (`MGP_MultiLanguage_rep1 "pkr.serv.objSelected" $selCount`) 0;
|
|
}
|
|
else if($control && $shift)
|
|
{
|
|
MGP_ScriptEditorFeedback (`MGP_MultiLanguage_rep1 "pkr.serv.objAddSelected" $selCount`) 0;
|
|
}
|
|
else
|
|
{
|
|
if($shift)
|
|
{
|
|
MGP_ScriptEditorFeedback (`MGP_MultiLanguage_rep1 "pkr.serv.objToggleSelected" $selCount`) 0;
|
|
}
|
|
else if($control)
|
|
{
|
|
MGP_ScriptEditorFeedback (`MGP_MultiLanguage_rep1 "pkr.serv.objDeselected" $selCount`) 0;
|
|
}
|
|
}
|
|
}
|
|
proc string mgp_makeSelectButtonCommandViaData(string $data)
|
|
{
|
|
string $cmd = "if(`exists MGP_EvalSelectionEx`)\n{\n MGP_EvalSelectionEx "+$data+";\n}\nelse\n{\n select "+$data+";\n}";
|
|
return $cmd;
|
|
}
|
|
global proc int MGP_InstallSelectButtonToShelf(string $tabName, string $label, string $objListString, string $toolTip)
|
|
{
|
|
global string $gShelfTopLevel;
|
|
if (!`tabLayout -exists $gShelfTopLevel`)
|
|
{
|
|
return 0;
|
|
}
|
|
string $shelfLayout = `mgp_activeOrCreateShelfTab $tabName`;
|
|
if(!size($shelfLayout))
|
|
{
|
|
return 0;
|
|
}
|
|
if(!size($objListString))
|
|
{
|
|
return 0;
|
|
}
|
|
string $cmd = `mgp_makeSelectButtonCommandViaData $objListString`;
|
|
string $defaultIcon = "selectByHierarchy.png";// "selectComp.png"; //"SP_FileDialogForward.png"; //"selectByHierarchy.png"; //"mayaIcon.png";
|
|
string $sb=`shelfButton
|
|
-label $label
|
|
-iol $label
|
|
-parent ($gShelfTopLevel + "|" +$shelfLayout)
|
|
-command $cmd
|
|
-image $defaultIcon
|
|
-annotation $toolTip
|
|
-overlayLabelBackColor 0 0 0 .6
|
|
`;
|
|
control -e -vis 1 $sb;
|
|
return 1;
|
|
}
|
|
proc string mgp_makeCommandButtonCommandViaData(string $data)
|
|
{
|
|
string $rep1 = "MGP_GetCurrentPickerNamespace";
|
|
string $rep2 = "MGPickerView -q -namespace";
|
|
return $data;
|
|
}
|
|
global proc int MGP_InstallCommandButtonDataToShelf(string $tabName, string $label, string $cmdType, string $shelfCmd, string $toolTip)
|
|
{
|
|
global string $gShelfTopLevel;
|
|
if (!`tabLayout -exists $gShelfTopLevel`)
|
|
{
|
|
return 0;
|
|
}
|
|
string $shelfLayout = `mgp_activeOrCreateShelfTab $tabName`;
|
|
if(!size($shelfLayout))
|
|
{
|
|
return 0;
|
|
}
|
|
if(!size($shelfCmd))
|
|
{
|
|
return 0;
|
|
}
|
|
string $cmd = `mgp_makeCommandButtonCommandViaData $shelfCmd`;
|
|
string $sourceType = "mel";
|
|
string $defaultIcon = "commandButton.png";
|
|
if(`tolower $cmdType` == "python")
|
|
{
|
|
$defaultIcon = "pythonFamily.png";
|
|
$sourceType = "python";
|
|
}
|
|
|
|
string $sb=`shelfButton
|
|
-label $label
|
|
-iol $label
|
|
-parent ($gShelfTopLevel + "|" +$shelfLayout)
|
|
-command $cmd
|
|
-image $defaultIcon
|
|
-annotation $toolTip
|
|
-overlayLabelBackColor 0 0 0 .6
|
|
`;
|
|
control -e -vis 1 $sb;
|
|
return 1;
|
|
}
|
|
|
|
//hierarchy sorting--------------------------------
|
|
global proc int[] MGP_SortHierarchyDepth_ReturnIndex(string $objList[])
|
|
{
|
|
int $result[];
|
|
|
|
string $sortList[] = `MGP_SortHierarchyDepth_ReturnObjects $objList`;
|
|
int $unexistCount = 0;
|
|
//append the unexists:
|
|
for($i=0; $i<size($objList);$i++)
|
|
{
|
|
if (!objExists($objList[$i]))
|
|
{
|
|
$sortList[size($sortList)] = $objList[$i];
|
|
$unexistCount ++;
|
|
}
|
|
}
|
|
int $c = `size $objList`;
|
|
for($i=0; $i<$c; $i++)
|
|
{
|
|
int $index = 0;
|
|
for($j=0; $j<$c; $j++)
|
|
{
|
|
if($sortList[$j] == $objList[$i])
|
|
{
|
|
$result[size($result)] = $j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if($unexistCount)
|
|
{
|
|
MGP_ScriptEditorFeedback(`MGP_MultiLanguage_rep1 "pkr.hierarchySort.noexist" $unexistCount`,1);
|
|
}
|
|
return $result;
|
|
|
|
} // end hierarchy DepthSort
|
|
|
|
global proc string[] MGP_SortHierarchyDepth_ReturnObjects(string $objList[])
|
|
//sort the obj list from top hierarchy to children hierarchy
|
|
{
|
|
string $sortList[] = {};
|
|
for ($obj in $objList)
|
|
{
|
|
if(objExists($obj))
|
|
{
|
|
int $depth = MGP_GetHierarchyDepth($obj,0);
|
|
//do padding so proper sort order
|
|
string $padDepth;
|
|
if ($depth < 10)
|
|
$padDepth = ("000" + $depth);
|
|
else if ($depth < 100)
|
|
$padDepth = ("00" + $depth);
|
|
else if ($depth < 1000)
|
|
$padDepth = ("0" + $depth);
|
|
else if ($depth < 10000)
|
|
$padDepth = ($depth);
|
|
string $prefixobj = ("-%" + $padDepth + "%-" + $obj);
|
|
$sortList = stringArrayCatenate({$prefixobj},$sortList);
|
|
}
|
|
}
|
|
$sortedList = sort($sortList);
|
|
string $sortListClean[] = {};
|
|
string $sorted;
|
|
for($sorted in $sortedList)
|
|
{
|
|
//print ($sorted + "\n");
|
|
string $regularExpr = "-%.*%-";
|
|
string $clean = `MGP_substitute $regularExpr $sorted ""`;
|
|
//print ($clean + "\n");
|
|
$sortListClean = stringArrayCatenate($sortListClean,{$clean});
|
|
}
|
|
//print $sortListClean;
|
|
return $sortListClean;
|
|
|
|
} // end hierarchy DepthSort
|
|
|
|
|
|
global proc int MGP_GetHierarchyDepth(string $object,int $depth)
|
|
{
|
|
|
|
while ($object != MGP_TraceConstraintParent($object) )
|
|
{
|
|
$object = MGP_TraceConstraintParent($object);
|
|
$depth++;
|
|
}
|
|
string $parent[] = `listRelatives -p $object`;
|
|
|
|
if (!size($parent))
|
|
{
|
|
return $depth;
|
|
}
|
|
|
|
$depth++;
|
|
//print ("Parent: "+$parent[0]+"\n");
|
|
return(MGP_GetHierarchyDepth($parent[0],$depth));
|
|
}
|
|
|
|
global proc string MGP_TraceConstraintParent(string $object)
|
|
{
|
|
//list connections on translate, rotate shouldn't matter since it's absolute
|
|
string $transConnections[] = {};
|
|
string $transConnectionsX[] = `listConnections -scn true -destination false -source true ($object + ".translateX")`;
|
|
string $transConnectionsY[] = `listConnections -scn true -destination false -source true ($object + ".translateY")`;
|
|
string $transConnectionsZ[] = `listConnections -scn true -destination false -source true ($object + ".translateZ")`;
|
|
|
|
string $rotConnectionsX[] = `listConnections -scn true -destination false -source true ($object + ".rotateX")`;
|
|
string $rotConnectionsY[] = `listConnections -scn true -destination false -source true ($object + ".rotateY")`;
|
|
string $rotConnectionsZ[] = `listConnections -scn true -destination false -source true ($object + ".rotateZ")`;
|
|
|
|
$transConnections = stringArrayCatenate($transConnectionsX,$transConnections);
|
|
$transConnections = stringArrayCatenate($transConnectionsY,$transConnections);
|
|
$transConnections = stringArrayCatenate($transConnectionsZ,$transConnections);
|
|
|
|
$transConnections = stringArrayCatenate($rotConnectionsX,$transConnections);
|
|
$transConnections = stringArrayCatenate($rotConnectionsY,$transConnections);
|
|
$transConnections = stringArrayCatenate($rotConnectionsZ,$transConnections);
|
|
|
|
$transConnections = stringArrayRemoveDuplicates($transConnections);
|
|
|
|
string $returnString = $object;
|
|
|
|
if (size($transConnections))
|
|
{
|
|
|
|
string $connected = $transConnections[0];
|
|
//check to see if type is parent or point
|
|
//string $connected = "pSphere1_pointConstraint1";
|
|
if (`objectType -isType "pointConstraint" $connected` || `objectType -isType "parentConstraint" $connected` )
|
|
{
|
|
int $validIndice[] = `getAttr -multiIndices ($connected + ".target")`;
|
|
if(!size($validIndice))
|
|
{
|
|
return $returnString;
|
|
}
|
|
int $targetIndex = 0;
|
|
float $targetWeight = 0;
|
|
for($index in $validIndice)
|
|
{
|
|
float $compareWeight = `getAttr ($connected + ".target[" + $index + "].targetWeight")`;
|
|
if ($targetWeight < $compareWeight)
|
|
{
|
|
$targetWeight = $compareWeight;
|
|
$targetIndex = $index;
|
|
}
|
|
}
|
|
|
|
string $connectedTransform[] = `listConnections ($connected + ".target[" + $targetIndex + "].targetParentMatrix")`;
|
|
|
|
$returnString = $connectedTransform[0];
|
|
}
|
|
}
|
|
return $returnString;
|
|
|
|
} // end MGP_TraceConstraintParent
|
|
|
|
|
|
//-------namespace--------------------------------
|
|
global proc MGP_SetPickerNamespace_Via_Selection()
|
|
{
|
|
string $mgp_namespace = `MGP_getSelectionNamespace`;
|
|
if(!size($mgp_namespace))
|
|
{
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage "pkr.serv.mustSelectReferencedObj.war"` 1;
|
|
}
|
|
else
|
|
{
|
|
MGP_SetCurrentPickerNamespace $mgp_namespace;
|
|
MGP_ScriptEditorFeedback `MGP_MultiLanguage_rep1 "pkr.serv.namespaceSet.rep" $mgp_namespace` 0;
|
|
}
|
|
}
|
|
|
|
//===================================================Read File codes =====================================================
|
|
global proc string [] MGP_ReadFileArray(string $file)
|
|
{
|
|
// read every line and put it into a strig array
|
|
string $nextLine ,$getData[];
|
|
if(!`filetest -f $file `)
|
|
{
|
|
return $getData;
|
|
}
|
|
$readFileID=`fopen $file "r"`;
|
|
if(!$readFileID)
|
|
{
|
|
return {};
|
|
}
|
|
while(!`feof $readFileID`)
|
|
{
|
|
$nextLine=`fgetline $readFileID`;
|
|
if (size($nextLine)>0)
|
|
{
|
|
$getData[size($getData)]=strip ($nextLine);
|
|
}
|
|
}
|
|
fclose $readFileID;
|
|
return $getData;
|
|
}
|
|
|
|
global proc string MGP_ReadFileString(string $file)
|
|
{
|
|
//read every line and put it into a string
|
|
string $nextLine ,$getDataString;
|
|
if(!`filetest -f $file`)
|
|
{
|
|
return "";
|
|
}
|
|
$readFileID=`fopen $file "r"`;
|
|
if(!$readFileID)
|
|
{
|
|
return "";
|
|
}
|
|
while(!`feof $readFileID`)
|
|
{
|
|
$nextLine=`fgetline $readFileID`;
|
|
if (size($nextLine)>0)
|
|
{
|
|
$getDataString=($getDataString+$nextLine);
|
|
}
|
|
}
|
|
fclose $readFileID;
|
|
return $getDataString;
|
|
}
|
|
|
|
global proc string [] MGP_ReadFileSepArray(string $file,string $sep)
|
|
{
|
|
//read every line and separate it with $sep,and put every part into a string array.
|
|
string $getData[];
|
|
if(!`filetest -f $file `)
|
|
{
|
|
return $getData;
|
|
}
|
|
if(!size($sep))
|
|
{
|
|
$sep = "\r\n";
|
|
}
|
|
string $nextLine ,$getDataString;
|
|
$readFileID=`fopen $file "r"`;
|
|
if(!$readFileID)
|
|
{
|
|
return {};
|
|
}
|
|
while(!`feof $readFileID`)
|
|
{
|
|
$nextLine=`fgetline $readFileID`;
|
|
if (size($nextLine)>0)
|
|
{
|
|
$getDataString=($getDataString+$nextLine);
|
|
}
|
|
}
|
|
$numTokens = `tokenize $getDataString $sep $getData`;
|
|
fclose $readFileID;
|
|
|
|
return $getData;
|
|
}
|
|
|
|
//-----------------viewport---------------------------------
|
|
global proc string MGP_GetActivedModelView()
|
|
{
|
|
string $result = `getPanel -withFocus`;
|
|
string $activeViewType=`getPanel -typeOf $result`;
|
|
if($activeViewType != "modelPanel")
|
|
{
|
|
return "";
|
|
}
|
|
return $result;
|
|
}
|
|
global proc string[] MGP_GetAllVisibleModelViews()
|
|
{
|
|
string $allViews[];
|
|
clear $allViews;
|
|
string $allVisViews []=`getPanel -vis`;
|
|
for ($eachTV in $allVisViews)
|
|
{
|
|
if(`getPanel -typeOf $eachTV` == "modelPanel")
|
|
{
|
|
$allViews [size($allViews)]=$eachTV;
|
|
}
|
|
}
|
|
return $allViews;
|
|
}
|
|
global proc MGP_ApplyViewPortConfigs_ex(string $configs[])
|
|
//hold control key to apply to all visible model views.
|
|
{
|
|
int $mods[] = `MGP_GetKeyboardModifiers`;
|
|
int $control = $mods[0];
|
|
MGP_ApplyViewPortConfigs $control $configs;
|
|
}
|
|
proc string mgp_getMelFlagStringFromViewportConfig(string $config)
|
|
{
|
|
$config = tolower(strip($config));
|
|
if(!size($config))
|
|
{
|
|
return "";
|
|
}
|
|
string $datas[]=`stringToStringArray $config "="`;
|
|
if(size($datas) != 2)
|
|
{
|
|
return "";
|
|
}
|
|
string $flag = strip($datas[0]);
|
|
int $value = strip($datas[1]);
|
|
global string $melFlags [];
|
|
$melFlags = {"-allObjects",
|
|
"-nurbsCurves",
|
|
"-nurbsSurfaces",
|
|
"-controlVertices",
|
|
"-hulls",
|
|
"-polymeshes",
|
|
"-subdivSurfaces",
|
|
"-planes",
|
|
"-lights",
|
|
"-cameras",
|
|
"-imagePlane",
|
|
"-joints",
|
|
"-ikHandles",
|
|
"-deformers",
|
|
"-dynamics",
|
|
"-particleInstancers",
|
|
"-fluids",
|
|
"-hairSystems",
|
|
"-follicles",
|
|
"-nCloths",
|
|
"-nParticles",
|
|
"-nRigids",
|
|
"-dynamicConstraints",
|
|
"-locators",
|
|
"-dimensions",
|
|
"-pivots",
|
|
"-handles",
|
|
"-textures",
|
|
"-strokes",
|
|
"-motionTrails",
|
|
"-pluginShapes",
|
|
"-clipGhosts",
|
|
"-greasePencils",
|
|
"-pluginObjects gpuCacheDisplayFilter",
|
|
//---------
|
|
"-manipulators",
|
|
"-grid",
|
|
"-headsUpDisplay",
|
|
"-selectionHiliteDisplay"
|
|
};
|
|
for($each in $melFlags)
|
|
{
|
|
string $cFlag = tolower($each);
|
|
if(($flag == $cFlag) || (("-"+$flag) == $cFlag))
|
|
{
|
|
return ($each+" "+$value);
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
global proc MGP_ApplyViewPortConfigs(int $applyToAll, string $configs[])
|
|
//configs should be string array,each element of it should be falg = value.
|
|
//eg. allObjects = 1, NURBS Curves = 0, etc.
|
|
{
|
|
if(!size($configs))
|
|
{
|
|
return;
|
|
}
|
|
string $views[];
|
|
if($applyToAll)
|
|
{
|
|
$views = `MGP_GetAllVisibleModelViews`;
|
|
}
|
|
else
|
|
{
|
|
string $activeV = `MGP_GetActivedModelView`;
|
|
if(size($activeV))
|
|
{
|
|
$views[0] = $activeV;
|
|
}
|
|
}
|
|
if(!size($views))
|
|
{
|
|
MGP_ScriptEditorFeedback "No model editor actived / visible to set the config." 1;
|
|
return;
|
|
}
|
|
string $flags[];
|
|
for($c in $configs)
|
|
{
|
|
string $cc = `mgp_getMelFlagStringFromViewportConfig $c`;
|
|
if(size($cc))
|
|
{
|
|
$flags[size($flags)] = $cc;
|
|
}
|
|
}
|
|
string $cmd = "modelEditor -e " + `stringArrayToString $flags " "` + " ";
|
|
for($each in $views)
|
|
{
|
|
catch(`eval ($cmd+$each)`);
|
|
}
|
|
}
|
|
global proc MGP_ViewShowOnlyGeometry(int $applyToAllViews)
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
$configs[size($configs)] = "nurbsSurfaces=1";
|
|
$configs[size($configs)] = "polymeshes=1";
|
|
$configs[size($configs)] = "subdivSurfaces=1";
|
|
MGP_ApplyViewPortConfigs $applyToAllViews $configs;
|
|
}
|
|
global proc MGP_ViewShowOnlyGeometryWithCurve(int $applyToAllViews)
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
$configs[size($configs)] = "nurbsSurfaces=1";
|
|
$configs[size($configs)] = "polymeshes=1";
|
|
$configs[size($configs)] = "subdivSurfaces=1";
|
|
$configs[size($configs)] = "nurbsCurves=1";
|
|
MGP_ApplyViewPortConfigs $applyToAllViews $configs;
|
|
}
|
|
global proc MGP_ViewShowOnlyGeometry_Ex()
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
$configs[size($configs)] = "nurbsSurfaces=1";
|
|
$configs[size($configs)] = "polymeshes=1";
|
|
$configs[size($configs)] = "subdivSurfaces=1";
|
|
MGP_ApplyViewPortConfigs_ex $configs;
|
|
}
|
|
global proc MGP_ViewShowOnlyGeometryWithCurve_Ex()
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
$configs[size($configs)] = "nurbsSurfaces=1";
|
|
$configs[size($configs)] = "polymeshes=1";
|
|
$configs[size($configs)] = "subdivSurfaces=1";
|
|
$configs[size($configs)] = "nurbsCurves=1";
|
|
MGP_ApplyViewPortConfigs_ex $configs;
|
|
}
|
|
global proc MGP_ViewShowAll(int $applyToAllViews)
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=1";
|
|
MGP_ApplyViewPortConfigs $applyToAllViews $configs;
|
|
}
|
|
global proc MGP_ViewShowAll_Ex()
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=1";
|
|
MGP_ApplyViewPortConfigs_ex $configs;
|
|
}
|
|
global proc MGP_ViewShowNone(int $applyToAllViews)
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
MGP_ApplyViewPortConfigs $applyToAllViews $configs;
|
|
}
|
|
global proc MGP_ViewShowNone_Ex()
|
|
{
|
|
string $configs[];
|
|
$configs[size($configs)] = "allObjects=0";
|
|
MGP_ApplyViewPortConfigs_ex $configs;
|
|
}
|
|
|
|
//camera code-----------------------------------
|
|
global proc MGP_SetActiveViewCamera(string $cam)
|
|
{
|
|
$cam = strip($cam);
|
|
if(!size($cam))
|
|
{
|
|
return;
|
|
}
|
|
if(!`objExists $cam`)
|
|
{
|
|
MGP_ScriptEditorFeedback ("Camera: "+$cam+" does not exist.") 1;
|
|
return;
|
|
}
|
|
string $activeView = `MGP_GetActivedModelView`;
|
|
if(!size($activeView))
|
|
{
|
|
MGP_ScriptEditorFeedback "No active 3d viewport found." 1;
|
|
return;
|
|
}
|
|
modelPanel -e -cam $cam $activeView;
|
|
}
|
|
global proc MGP_SetActiveViewCamera_AutoNamespace(string $cam)
|
|
{
|
|
$cam = strip($cam);
|
|
if(!size($cam))
|
|
{
|
|
return;
|
|
}
|
|
string $ns = `MGPickerView -q -namespace`;
|
|
string $temp[]=`stringToStringArray $cam ":"`;
|
|
string $camNoNS = $cam;
|
|
if(size($temp)>1)
|
|
{
|
|
$camNoNS = $temp[size($temp)-1];
|
|
}
|
|
if(size($ns))
|
|
{
|
|
$cam = ($ns+":"+$camNoNS);
|
|
}
|
|
else
|
|
{
|
|
$cam = $camNoNS;
|
|
}
|
|
MGP_SetActiveViewCamera $cam;
|
|
}
|
|
|
|
//------------test the current preferred maya tool to switch to------------
|
|
proc int[] mgp_testObjLockStatus(string $obj)
|
|
{
|
|
int $result[] = {0,0,0};
|
|
if(`nodeType $obj` != "transform")
|
|
{
|
|
return $result;
|
|
}
|
|
if(`getAttr -l ($obj+".tx")` && `getAttr -l ($obj+".ty")` && `getAttr -l ($obj+".tz")`)
|
|
{
|
|
$result[0] = 1;
|
|
}
|
|
if(`getAttr -l ($obj+".rx")` && `getAttr -l ($obj+".ry")` && `getAttr -l ($obj+".rz")`)
|
|
{
|
|
$result[1] = 1;
|
|
}
|
|
if(`getAttr -l ($obj+".sx")` && `getAttr -l ($obj+".sy")` && `getAttr -l ($obj+".sz")`)
|
|
{
|
|
$result[2] = 1;
|
|
}
|
|
return $result;
|
|
}
|
|
global proc string MGP_TestPreferredMayaToolToSwitch(string $objs[])
|
|
{
|
|
if(!size($objs))
|
|
{
|
|
return "";
|
|
}
|
|
int $TAvailable = 0;
|
|
int $RAvailable = 0;
|
|
int $SAvailable = 0;
|
|
for($obj in $objs)
|
|
{
|
|
int $lock[] =`mgp_testObjLockStatus $obj`;
|
|
if(!$lock[0])
|
|
{
|
|
$TAvailable = 1;
|
|
}
|
|
if(!$lock[1])
|
|
{
|
|
$RAvailable = 1;
|
|
}
|
|
if(!$lock[2])
|
|
{
|
|
$SAvailable = 1;
|
|
}
|
|
}
|
|
if(($TAvailable + $RAvailable + $SAvailable) == 1)
|
|
{
|
|
if($TAvailable)
|
|
{
|
|
return "t";
|
|
}
|
|
if($RAvailable)
|
|
{
|
|
return "r";
|
|
}
|
|
if($SAvailable)
|
|
{
|
|
return "s";
|
|
}
|
|
}
|
|
return "";
|
|
} |