1828 lines
52 KiB
Text
1828 lines
52 KiB
Text
// Anim exporter
|
|
|
|
// Notes:
|
|
//
|
|
// We need a window that can export animations
|
|
//
|
|
//
|
|
// The animation file needs to store,
|
|
//
|
|
/*
|
|
|
|
1. A list of objects that make up the skeleton.
|
|
2. A list of export files.
|
|
|
|
These need to store:
|
|
|
|
1. File name
|
|
2. Start frame
|
|
3. End frame
|
|
4. Sample rate
|
|
5. Skeleton list
|
|
|
|
6. Note track
|
|
3.
|
|
|
|
|
|
Vars in renderGlobal
|
|
|
|
Skeleton sets:
|
|
|
|
SkelNumber : int Number of skeleton sets stored in the file.
|
|
|
|
|
|
NumOfJointsSkelxx : int The number of joints or nodes that are stored in the skeleton set. xx is the skeleton number.
|
|
|
|
Jointxx : message Connection to joint or node. The xx is the number of the joint/node in the skeleton list.
|
|
This uses the message attribute so that the object it is connected to can be re-named.
|
|
|
|
|
|
Animation export data
|
|
|
|
AnimationNumber : int The number of animations in the export settings
|
|
|
|
|
|
AnimFileNamexx : string The file name for the exporter. xx is the animation number
|
|
|
|
AnimStartxx : int The start frame of animation xx
|
|
|
|
AnimEndxx : int The end frame of animation xx
|
|
|
|
AnimSamplexx : int The sample rate of the animation export xx
|
|
|
|
AnimSkeletonxx : int The skeleton number to use in the animation export xx
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
Added so far:
|
|
|
|
int renderGlobal.AnimationCount the number of animation export settings stored in the renderGlobals
|
|
|
|
Each animation entry has these attributes so far :
|
|
|
|
FileName#
|
|
|
|
FrameStart#
|
|
|
|
FrameEnd#
|
|
|
|
ExportNodes# -type string . MEL dosen't allow string arrays as dynamic attributes, so the export nodes are stored as one big
|
|
string which is a select command so that the string can use eval
|
|
|
|
ExportNoteTrack# - Which note track, if any, to be exported with the animation.
|
|
|
|
|
|
IMPORTANT
|
|
|
|
To add or remove attributes to the main list, the following procs have to be altered
|
|
|
|
RemoveAnimationAttributes
|
|
AddAnimationAttributes
|
|
DeleteSelectedAnimations
|
|
DisplayAnimationLine
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Global Proc List
|
|
|
|
CheckExportAttributes
|
|
SelectListNoteTrack
|
|
SelectListExportNodes
|
|
AddSelNoteTrack
|
|
ExportAnimation
|
|
StartTheExport
|
|
ListExportNodes
|
|
SetExportNodes
|
|
SelectExportNodes
|
|
CODExporterFileBrowes
|
|
UpdateNameFromBroweser
|
|
DeleteSelectedAnimations
|
|
DisplayAnimationList
|
|
DisplayAnimationLine
|
|
ChangeFileName
|
|
ChangeFrameStart
|
|
ChangeFrameEnd
|
|
RemoveAnimationAttributes
|
|
AddAnimationAttributes
|
|
AddAnimation
|
|
CreateCODExportWindow
|
|
CreateCODExportWindowCB
|
|
CODExportAnimationWindow
|
|
RemoveNoteTrack
|
|
|
|
*/
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: doubleCheckStuff
|
|
//
|
|
// This is called just before the export so extra checks can be added.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc doubleCheckStuff( int $ExportNumber)
|
|
{
|
|
|
|
// Check to see if the helmet joint is in the list.
|
|
// This joint was missing from a lot of the earlier export settings which messed up the animation export.
|
|
|
|
// Get the list of export nodes
|
|
|
|
string $ExportNodes = `getAttr ("IWGlobalNode.ExportNodes" + $ExportNumber)`;
|
|
|
|
print $ExportNodes;
|
|
|
|
// Check to see if DefMesh:J_Helmet is in the list
|
|
|
|
if (`gmatch $ExportNodes "*DefMesh:J_Helmet*"`)
|
|
{
|
|
// Check that the problem joint, rig:DefMesh:J_Head_END is also in there, if not add it.
|
|
|
|
if (`gmatch $ExportNodes "*DefMesh:J_Head_END*"` == 0)
|
|
{
|
|
print "\nThe head end joint is missing";
|
|
// Need to add the head end joint.
|
|
// First calc the prefex
|
|
|
|
string $Pref[];
|
|
|
|
tokenize $ExportNodes ":" $Pref;
|
|
|
|
print "\n";
|
|
print $Pref[0];
|
|
|
|
// Add the joint to the list
|
|
|
|
$ExportNodes = $ExportNodes + (" " + $Pref[0] + ":" + "DefMesh:J_Head_END");
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $ExportNumber) $ExportNodes;
|
|
}
|
|
else print "\nThe head end joint is there";
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
global proc SelectListNoteTrack (int $AnimNum)
|
|
{
|
|
|
|
// Get a list of the note tracks from the note track mel script
|
|
|
|
source NoteTrack;
|
|
|
|
string $NoteTrackList[] = `GetNoteTrackList`;
|
|
|
|
string $EachNote;
|
|
|
|
print "\n\n\n";
|
|
print $NoteTrackList;
|
|
|
|
|
|
// Open a selection confirmDialog to select the Note Track using a created Eval command
|
|
|
|
string $DialogEval = ("confirmDialog -title \"Prefix\" -message \"Select a Note Track\" ");
|
|
|
|
|
|
for ($EachNote in $NoteTrackList)
|
|
{
|
|
$DialogEval = $DialogEval + (" -button \"" + $EachNote + ":\" ");
|
|
|
|
}
|
|
|
|
$DialogEval = $DialogEval + (" -b \"Cancel\" -cb \"Cancel\"");
|
|
|
|
string $SelNoteTrack = `eval $DialogEval`;
|
|
|
|
if ($SelNoteTrack != "Cancel" && $SelNoteTrack != "dismiss")
|
|
{
|
|
|
|
select -r $SelNoteTrack;
|
|
|
|
AddSelNoteTrack $AnimNum;
|
|
|
|
select -cl;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: SelectListExportNodes
|
|
//
|
|
// This procedure opens a selection window similar to the List COD Character button in the GUI.
|
|
// It is used to select a deformation skeleton set for the export nodes in the exporter
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc SelectListExportNodes(int $AnimNum)
|
|
{
|
|
|
|
source ListCODChars;
|
|
|
|
string $AllChars[] = `ListCODChars`;
|
|
|
|
// Tokenize the list with : to get the prefix
|
|
|
|
string $EachChar;
|
|
string $CharList[];
|
|
int $CharCount = 0;
|
|
int $getCharType;
|
|
|
|
print "\nStart COD list\n";
|
|
|
|
for ($EachChar in $AllChars)
|
|
{
|
|
string $Tokenize[];
|
|
clear $Tokenize;
|
|
|
|
tokenize $EachChar ":" $Tokenize;
|
|
|
|
// If this is a viewmodel then just set it from the button and return
|
|
|
|
if($AllChars[0] == "rig:CODViewModelLocatorShape")
|
|
{
|
|
select -r "VM_Gun:J_Gun";
|
|
select -hi;
|
|
string $gunJoints[] = `ls -sl -type joint`;
|
|
|
|
select -r ($Tokenize[0] + ":DefMesh:DefViewSkeleton");
|
|
select -add $gunJoints;
|
|
|
|
SetExportNodes $AnimNum;
|
|
|
|
return;
|
|
}
|
|
|
|
// Make sure the size of $Tokenize is > 1 meaning there was a : in the original name.
|
|
|
|
if (`size $Tokenize` > 1 )
|
|
{
|
|
$CharList[$CharCount] = $Tokenize[0];
|
|
$CharCount++;
|
|
}
|
|
|
|
else
|
|
{
|
|
warning ($Tokenize[0] + " is not referenced.");
|
|
}
|
|
|
|
}
|
|
|
|
// Open a selection confirmDialog to select the prefix using a created Eval command
|
|
|
|
string $DialogEval = ("confirmDialog -title \"Prefix\" -message \"Select a Character\" ");
|
|
|
|
|
|
for ($EachChar in $CharList)
|
|
{
|
|
$DialogEval = $DialogEval + (" -button \"" + $EachChar + ":\" ");
|
|
}
|
|
|
|
$DialogEval = $DialogEval + (" -b \"Cancel\" -cb \"Cancel\"");
|
|
|
|
print "\n\n";
|
|
|
|
|
|
string $Prefix = `eval $DialogEval`;
|
|
|
|
if ($Prefix != "Cancel" && $Prefix != "dismiss")
|
|
{
|
|
|
|
// Need to add in the root tag node to this first because it is not in the deformation skeleton
|
|
|
|
select -r ($Prefix + "DefMesh:TAG_ORIGIN");
|
|
|
|
select -add ($Prefix + "DefMesh:DefSkeleton");
|
|
|
|
|
|
SetExportNodes $AnimNum;
|
|
|
|
select -cl;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: RemoveNoteTrack
|
|
//
|
|
// This procedure removes the note track from the export window
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc RemoveNoteTrack(int $AnimNumber)
|
|
{
|
|
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $AnimNumber) "NO NOTE TRACK";
|
|
|
|
// update the text in the window
|
|
text -e -bgc 1 0 0.7 -label " NO NOTE TRACK" ("NoteTrackWindowText" + $AnimNumber);
|
|
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: AddSelNoteTrack
|
|
//
|
|
// This procedure adds the selected note track to the exporter settings.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc AddSelNoteTrack(int $AnimNumber)
|
|
{
|
|
|
|
string $Sel[] = `ls -sl`;
|
|
|
|
//First check somthing is selected
|
|
if (`size $Sel[0]` == 0)
|
|
{
|
|
warning "Please select a NoteTrack";
|
|
return;
|
|
}
|
|
|
|
|
|
// Check the selected node is a NoteTrack
|
|
|
|
string $CheckNote = `substring $Sel[0] 1 9`;
|
|
|
|
print ("Checking note track : " + $CheckNote);
|
|
|
|
if ($CheckNote == "NoteTrack" )
|
|
{
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $AnimNumber) $Sel[0];
|
|
|
|
// update the text in the window
|
|
text -e -bgc 0.9 0.9 0.9 -label (" " + $Sel[0] + " ") ("NoteTrackWindowText" + $AnimNumber);
|
|
|
|
}
|
|
else
|
|
{
|
|
warning "Please select a NoteTrack";
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ExportAnimation
|
|
//
|
|
// This procedure calls the exporter and exports a animation from the animation window.
|
|
// The animation it exports is passed into this function in (int $AnimNumber)
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ExportAnimation(int $AnimNumber)
|
|
{
|
|
|
|
// Collect all the export data from the window
|
|
|
|
// int $StartFrame[] = `intFieldGrp -q -v ("FrameStart" + $AnimNumber)`;
|
|
// int $EndFrame[] = `intFieldGrp -q -v ("FrameEnd" + $AnimNumber)`;
|
|
|
|
int $FrameRate;
|
|
string $timeUnit;
|
|
|
|
int $StartFrame = `getAttr ("IWGlobalNode.FrameStart" + $AnimNumber)`;
|
|
int $EndFrame = `getAttr ("IWGlobalNode.FrameEnd" + $AnimNumber)`;
|
|
|
|
$timeUnit = `currentUnit -q -time`;
|
|
switch ( $timeUnit )
|
|
{
|
|
case "2fps":
|
|
$FrameRate = 2;
|
|
break;
|
|
case "3fps":
|
|
$FrameRate = 3;
|
|
break;
|
|
case "4fps":
|
|
$FrameRate = 4;
|
|
break;
|
|
case "5fps":
|
|
$FrameRate = 5;
|
|
break;
|
|
case "6fps":
|
|
$FrameRate = 6;
|
|
break;
|
|
case "8fps":
|
|
$FrameRate = 8;
|
|
break;
|
|
case "10fps":
|
|
$FrameRate = 10;
|
|
break;
|
|
case "12fps":
|
|
$FrameRate = 12;
|
|
break;
|
|
case "16fps":
|
|
$FrameRate = 16;
|
|
break;
|
|
case "20fps":
|
|
$FrameRate = 20;
|
|
break;
|
|
case "40fps":
|
|
$FrameRate = 40;
|
|
break;
|
|
case "game":
|
|
$FrameRate = 15;
|
|
break;
|
|
case "film":
|
|
$FrameRate = 24;
|
|
break;
|
|
case "pal":
|
|
$FrameRate = 25;
|
|
break;
|
|
case "ntsc":
|
|
$FrameRate = 30;
|
|
break;
|
|
case "show":
|
|
$FrameRate = 48;
|
|
break;
|
|
case "palf":
|
|
$FrameRate = 50;
|
|
break;
|
|
case "ntscf":
|
|
$FrameRate = 60;
|
|
break;
|
|
default:
|
|
error ("Invalid time unit " + $timeUnit );
|
|
break;
|
|
}
|
|
|
|
string $PartsArray[];
|
|
clear $PartsArray;
|
|
string $Parts = `getAttr ("IWGlobalNode.ExportNodes" + $AnimNumber)`;
|
|
|
|
tokenize $Parts " " $PartsArray;
|
|
|
|
string $FileName = `getAttr ("IWGlobalNode.FileName" + $AnimNumber)`;
|
|
|
|
string $NoteTrack = `getAttr ("IWGlobalNode.ExportNoteTrack" + $AnimNumber)`;
|
|
|
|
// Test prints
|
|
print ("\n\nExport animation number " + $AnimNumber + "\n");
|
|
print ("\nStart frame = " + $StartFrame);
|
|
print ("\nEnd frame = " + $EndFrame);
|
|
print ("\nExport joints : \n");
|
|
print $PartsArray;
|
|
print ("\nPartsArry size = " + (`size $PartsArray`));
|
|
print ("\nFilename : " + $FileName);
|
|
print ("\nNoteTrack : " + $NoteTrack);
|
|
|
|
// Double check that the helmet will work because I'm fed up with this problem croping up all the time.
|
|
|
|
doubleCheckStuff $AnimNumber;
|
|
|
|
|
|
|
|
|
|
// Switch the gun to the correct gun for export
|
|
|
|
// Get the prefix of the exporting animation
|
|
|
|
string $PartsTok[];
|
|
|
|
tokenize $PartsArray[0] ":" $PartsTok;
|
|
|
|
string $PartsPref = ($PartsTok[0] + ":");
|
|
|
|
print "\n\nParts prefix = ";
|
|
print $PartsPref;
|
|
print "\n\n";
|
|
|
|
|
|
// Get the gun to switch to.
|
|
|
|
// First check that the attribute exists - Brians script wont open the window which adds the attribute
|
|
// The attribute does not exist, then skip the gun switching which is the same as default
|
|
|
|
if (`attributeExists ("GunNumber" + $AnimNumber) IWGlobalNode`)
|
|
{
|
|
|
|
int $GunSelection = `getAttr ("IWGlobalNode.GunNumber" + $AnimNumber)`;
|
|
|
|
// check for gun default, which is 1.
|
|
|
|
if ($GunSelection > 1)
|
|
{
|
|
// If this is greater than 1, then a gun has been selected, so swith to it.
|
|
|
|
$GunSelection = $GunSelection -1; // Dec by 1 because the default setting adds 1 to the gun list.
|
|
|
|
// Make the switch
|
|
COD2_SwitchGun $GunSelection $PartsPref;
|
|
}
|
|
}
|
|
|
|
string $FileNameArray[];
|
|
int $FileNameArraySize;
|
|
int $FileNameArrayIndex;
|
|
string $upperCaseFileName;
|
|
string $command;
|
|
string $dirPath;
|
|
|
|
$FileNameArraySize = `tokenize $FileName "\\" $FileNameArray`;
|
|
$FileName = "";
|
|
|
|
if ( $FileNameArraySize > 1 )
|
|
{
|
|
for ( $FileNameArrayIndex = 0; $FileNameArrayIndex < $FileNameArraySize; $FileNameArrayIndex++ )
|
|
{
|
|
$FileName += $FileNameArray[$FileNameArrayIndex];
|
|
if ( $FileNameArrayIndex < $FileNameArraySize - 1 )
|
|
$FileName += "/";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$FileName = `getAttr ("IWGlobalNode.FileName" + $AnimNumber)`;
|
|
}
|
|
|
|
// change forward slashes to backslashes so we could pass it into "dirname"
|
|
$FileName = `substituteAllString $FileName "/" "\\"`;
|
|
|
|
// get the directory name, but it's going to give it to us in forward slashes
|
|
$dirPath = `dirname $FileName`;
|
|
|
|
// change forward slashes to backslashes because "mkdir" accepts only backslashes
|
|
$dirPath = `substituteAllString $dirPath "/" "\\"`;
|
|
system ( "mkdir " + $dirPath );
|
|
|
|
// change backslashes to forward slash for writing the file
|
|
$FileName = `substituteAllString $FileName "\\" "/"`;
|
|
|
|
// since there's a directory called xanim_export and our extension is XANIM_EXPORT,
|
|
// we can't just use "match" function like we did in model window...
|
|
// so get the filename without its full path and see if we need extension or not.
|
|
|
|
// periodCount and periods are used to tokenize the periods in the file name so that
|
|
// if an extension exists then it can be stripped out automatically and updated to a clean
|
|
// extension-less name in the exporter.
|
|
|
|
string $tokens[];
|
|
string $periods[];
|
|
int $periodCount = `tokenize $FileName "." $periods`;
|
|
int $tokenCount = `tokenize $FileName "/" $tokens`;
|
|
if ( $tokenCount > 0 )
|
|
{
|
|
|
|
if ($periodCount < 3)
|
|
{
|
|
$FileName = $periods[0];
|
|
}
|
|
|
|
else
|
|
{
|
|
$FileName = $periods[0] + ".";
|
|
|
|
for($i=1; $i<$periodCount-1; $i++)
|
|
{
|
|
if ($i == $periodCount-2)
|
|
{
|
|
$FileName += $periods[$i];
|
|
}
|
|
|
|
else
|
|
{
|
|
$FileName += $periods[$i] + ".";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $AnimNumber) $FileName;
|
|
|
|
$tokenCount = `tokenize $FileName "/" $tokens`;
|
|
$upperCaseFileName = `toupper $tokens[$tokenCount - 1]`;
|
|
if ( `match ".XANIM_EXPORT" $upperCaseFileName` == "" )
|
|
$FileName += ".XANIM_EXPORT";
|
|
|
|
}
|
|
|
|
ExportXAnim $StartFrame $EndFrame $FrameRate $Parts $FileName $NoteTrack;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ExportEverything
|
|
//
|
|
// This procedure exports all the animations. It is called by the batch exporter script only.
|
|
// The other proc StartTheExport needs the window open to check to selcted animations, so
|
|
// this version skips past that part and doesn't need the window open
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
global proc ExportEverything()
|
|
{
|
|
|
|
// Set up vars
|
|
|
|
int $loop;
|
|
|
|
int $AnimationCount;
|
|
|
|
// Get the animation list number
|
|
|
|
$AnimationCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
|
|
// if animation count is 0, return
|
|
|
|
if ($AnimationCount < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
for ($loop = 1; $loop <= $AnimationCount ;$loop++ )
|
|
{
|
|
// Just export it because we don't care if it's selected or not
|
|
ExportAnimation $loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: StartTheExport
|
|
//
|
|
// This procedure calls the ExportAnimation function and exports all the selected animations
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc StartTheExport( int $Selected )
|
|
{
|
|
// Set up vars
|
|
|
|
int $loop;
|
|
int $CheckBox;
|
|
int $AnimationCount;
|
|
int $pluginLoaded;
|
|
string $currentSceneName;
|
|
string $confirmResult;
|
|
string $saveMessage;
|
|
string $saveConfirmResult;
|
|
|
|
// Find out if any animations are selected.
|
|
// Get the animation list number
|
|
$AnimationCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
// if animation count is 0, return
|
|
if ($AnimationCount < 1)
|
|
return;
|
|
|
|
$currentSceneName = `file -q -sn`;
|
|
|
|
if ( `file -q -anyModified` > 0 )
|
|
{
|
|
$saveMessage = "Save changes to " + $currentSceneName + " ?";
|
|
$saveConfirmResult = `confirmDialog -title "Save Changes" -message $saveMessage -button "Yes" -button "No" -button "Cancel Export" -defaultButton "Yes" -cancelButton "Yes" -dismissString "No"`;
|
|
if ( $saveConfirmResult == "Yes" )
|
|
{
|
|
file -save;
|
|
}
|
|
if ( $saveConfirmResult == "Cancel Export" )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// check if the plugin is loaded. If not, load it. If that fails, error out
|
|
$pluginLoaded = `pluginInfo -q -loaded XAnimExport`;
|
|
if ( $pluginLoaded == 0 )
|
|
loadPlugin XAnimExport;
|
|
|
|
$pluginLoaded = `pluginInfo -q -loaded XAnimExport`;
|
|
if ( $pluginLoaded == 0 )
|
|
error ("XAnimExport plugin is not loaded");
|
|
|
|
for ($loop = 1; $loop <= $AnimationCount ;$loop++ )
|
|
{
|
|
|
|
// get checkbox of animation #loop if the selected flag is set
|
|
|
|
if ($Selected == 1)
|
|
{
|
|
|
|
$CheckBox = `checkBox -q -v ("Entry" + $loop)`;
|
|
|
|
if ($CheckBox == 1)
|
|
{
|
|
// Ths is a selected animation, so export it
|
|
ExportAnimation $loop;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Just export it because we don't care if it's selected or not
|
|
ExportAnimation $loop;
|
|
}
|
|
|
|
}
|
|
|
|
string $convert;
|
|
$convert = `getAttr "IWGlobalNode.postExportConvert"`;
|
|
if ( $convert == "PC Convert" )
|
|
RunConverter "PC";
|
|
else if ( $convert == "Xenon Convert" )
|
|
RunConverter "Xenon";
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ListExportNodes
|
|
//
|
|
// This procedure prints the list of export nodes to the script editor.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ListExportNodes (int $FileNumber)
|
|
{
|
|
|
|
string $Each;
|
|
|
|
string $ExportNodes = `getAttr ("IWGlobalNode.ExportNodes " + $FileNumber)`;
|
|
string $ExportNodesList[];
|
|
|
|
string $FileName = `textFieldButtonGrp -q -text ("FileNameTextField" + $FileNumber)`;
|
|
|
|
tokenize $ExportNodes " " $ExportNodesList;
|
|
|
|
print ("\n\nList of Export nodes for export #" + $FileNumber);
|
|
print "\nFilename : ";
|
|
print $FileName;
|
|
print "\n";
|
|
|
|
|
|
print $ExportNodesList;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: SetExportNodes
|
|
//
|
|
// This procedure loads the export list string (ExportNodes#) with the selected objects.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc SetExportNodes (int $FileNumber)
|
|
{
|
|
string $Sel[] = `ls -sl`;
|
|
|
|
string $Each;
|
|
|
|
string $ExportNodes;
|
|
|
|
for ($Each in $Sel)
|
|
{
|
|
$ExportNodes = $ExportNodes + $Each + " ";
|
|
}
|
|
|
|
// Get the prefix of the exported asset
|
|
|
|
string $tokNodes[];
|
|
tokenize $ExportNodes ":" $tokNodes;
|
|
|
|
// Check the export nodes list to update the status line
|
|
|
|
if (`size $ExportNodes`)
|
|
{
|
|
text -e -bgc 0.9 0.9 0.9 -e -label (" Prefix is " + $tokNodes[0] + ": ") ("ExportNodeCheck" + $FileNumber);
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $FileNumber) $ExportNodes;
|
|
}
|
|
else
|
|
{
|
|
text -e -bgc 1 0 0.7 -label " NO EXPORT NODES" ("ExportNodeCheck" + $FileNumber);
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $FileNumber) "";
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: SelectExportNodes
|
|
//
|
|
// This procedure selects all the nodes stored in the export list string (ExportNodes#)
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc SelectExportNodes( int $FileNumber)
|
|
{
|
|
|
|
string $ExportNodes = `getAttr ("IWGlobalNode.ExportNodes " + $FileNumber)`;
|
|
|
|
string $SelEval = ("select -r " + $ExportNodes);
|
|
|
|
eval $SelEval;
|
|
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CODExporterFileBrowes
|
|
//
|
|
// This procedure opens a file broweser window so that a file name can be selected
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
global proc CODExporterFileBrowes(int $FileNumber)
|
|
{
|
|
|
|
// "fileBrowserDialog -m 1 -fc \"CODSavePose\" -ft \".hand\" -an \"Save\"");
|
|
|
|
print "Testing call to CODExporterFileBrowes";
|
|
|
|
//fileBrowserDialog -mode 1 -fc ("UpdateNameFromBroweser " + $FileNumber) -an "Save");
|
|
|
|
fileBrowserDialog -m 1 -fc ("UpdateNameFromBroweser " + $FileNumber) -an "Set";
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: UpdateNameFromBroweser
|
|
//
|
|
// This procedure is called by the fileBrowserDialog.
|
|
// It loads the file name into the filename test box.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
global proc UpdateNameFromBroweser( int $FileNameNumber, string $filename, string $fileType )
|
|
{
|
|
|
|
print ("\nTest proc call to UpdateNameFromBroweser");
|
|
|
|
print ("\nFile number = " + $FileNameNumber);
|
|
print ("\nFileName = " + $filename);
|
|
|
|
// Set the text box file name
|
|
|
|
textFieldButtonGrp -e -text $filename ("FileNameTextField" + $FileNameNumber);
|
|
|
|
// Call the ChangeFileName function because changing the name above does not force the call like typing in a new name.
|
|
|
|
ChangeFileName $FileNameNumber;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: DeleteSelectedAnimations
|
|
//
|
|
// This procedure deletes any selected animation entrys and redraws the window.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
global proc DeleteSelectedAnimations()
|
|
{
|
|
// Unlock the node to add an attribute
|
|
|
|
lockNode -lock off IWGlobalNode;
|
|
|
|
// Set up vars
|
|
|
|
int $loop;
|
|
int $DelLoop;
|
|
|
|
int $CheckBox;
|
|
|
|
// Find out if any animations are selected.
|
|
|
|
// Get the animation list number
|
|
|
|
$AnimationCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
|
|
// if animation count is 0, return
|
|
|
|
if ($AnimationCount < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
for ($loop = 1; $loop <= $AnimationCount ;$loop++ )
|
|
{
|
|
|
|
// get checkbox of animation #loop
|
|
|
|
$CheckBox = `checkBox -q -v ("Entry" + $loop)`;
|
|
|
|
if ($CheckBox)
|
|
{
|
|
// delete the animation entry #loop
|
|
// need to move any entrys after this one down one and delete the last entry
|
|
|
|
|
|
for ($DelLoop = $loop; $DelLoop < $AnimationCount ; $DelLoop ++ )
|
|
{
|
|
// Testing, this is what I need to do
|
|
print "\n";
|
|
print ("Moving line " + ($DelLoop + 1) + " to line " + $DelLoop );
|
|
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $DelLoop) (`getAttr ("IWGlobalNode.FileName" + ($DelLoop + 1))`);
|
|
checkBox -e -v (`checkBox -q -v ("Entry" + ($DelLoop + 1))`) ("Entry" + $DelLoop);
|
|
|
|
setAttr ("IWGlobalNode.FrameStart" + $DelLoop) (`getAttr ("IWGlobalNode.FrameStart" + ($DelLoop + 1))`);
|
|
|
|
setAttr ("IWGlobalNode.FrameEnd" + $DelLoop) (`getAttr ("IWGlobalNode.FrameEnd" + ($DelLoop + 1))`);
|
|
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $DelLoop) (`getAttr ("IWGlobalNode.ExportNodes" + ($DelLoop + 1))`);
|
|
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $DelLoop) (`getAttr ("IWGlobalNode.ExportNoteTrack" + ($DelLoop + 1))`);
|
|
|
|
setAttr ("IWGlobalNode.GunNumber" + $DelLoop) (`getAttr ("IWGlobalNode.GunNumber" + ($DelLoop + 1))`);
|
|
|
|
|
|
}
|
|
|
|
// Delete the last animation entry's attributes
|
|
|
|
RemoveAnimationAttributes $AnimationCount;
|
|
|
|
|
|
$AnimationCount -- ;
|
|
|
|
setAttr IWGlobalNode.AnimationCount $AnimationCount;
|
|
|
|
// Force the loop to recheck the same checkbox in case the next one, which has just moved,
|
|
// was also checked for delete
|
|
|
|
$loop--;
|
|
}
|
|
}
|
|
|
|
|
|
// Redraw the window
|
|
|
|
CODExportAnimationWindow;
|
|
|
|
|
|
// Relock the node to protect it
|
|
|
|
lockNode IWGlobalNode;
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: DisplayAnimationList
|
|
//
|
|
// This procedure creates the animation list in the main window by gathering all the information it needs from the renderGlobals
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
global proc DisplayAnimationList()
|
|
{
|
|
|
|
// Set up some vars
|
|
|
|
int $loop;
|
|
|
|
|
|
// First get the number of animation export settings that are stored in the renderGlobals.
|
|
// If there are none, add 1 and set it to blank
|
|
|
|
int $AnimationCount;
|
|
|
|
if ( `attributeExists AnimationCount IWGlobalNode`)
|
|
{
|
|
|
|
$AnimationCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
}
|
|
|
|
else
|
|
{
|
|
// Unlock the node to add an attribute
|
|
|
|
lockNode -lock off IWGlobalNode;
|
|
|
|
// If there isn't a AnimationCount attribute, make one and set it to 1
|
|
|
|
addAttr -ln AnimationCount -at byte IWGlobalNode;
|
|
setAttr IWGlobalNode.AnimationCount 0;
|
|
|
|
$AnimationCount = 0;
|
|
return;
|
|
|
|
// Relock the node to protect it
|
|
|
|
lockNode IWGlobalNode;
|
|
|
|
}
|
|
|
|
|
|
// Create all the animation export buttons etc.
|
|
|
|
for ($loop = 1; $loop <= $AnimationCount ; $loop++)
|
|
{
|
|
if ( `attributeExists ( "FileName" + $loop ) IWGlobalNode` == 0 )
|
|
AddAnimationAttributes $loop;
|
|
|
|
CheckExportAttributes $loop;
|
|
DisplayAnimationLine $loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CheckExportAttributes
|
|
//
|
|
// This procedure checks for attributes in the IWGlobalNode to see if they all exist.
|
|
// The real reason for this check is to be able to add new attributes and not kill the exporter.
|
|
// Any new attributes that are added in the future can be checked for here so old animations will still export
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc CheckExportAttributes (int $ExportNumber)
|
|
{
|
|
|
|
// Check for gun number
|
|
|
|
if (`attributeExists ("GunNumber" + $ExportNumber) IWGlobalNode` == 0)
|
|
{
|
|
print ("\nMissing GunNumber attribute in export settings " + $ExportNumber + " so adding it\n");
|
|
addAttr -ln ("GunNumber" + $ExportNumber) -at long IWGlobalNode;
|
|
setAttr ("IWGlobalNode.GunNumber" + $ExportNumber) 1;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: DisplayAnimationLine
|
|
//
|
|
// This procedure adds the animation line to the window. It is called from the DisplayAnimationList proc
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc DisplayAnimationLine(int $loop)
|
|
{
|
|
|
|
// First get the data from the IWGlobalNode so the fields can be loaded
|
|
string $FileName = `getAttr ("IWGlobalNode.FileName" + $loop)`;
|
|
string $ExportNodeCheck = `getAttr ("IWGlobalNode.ExportNodes" + $loop)`;
|
|
string $NoteTrack = `getAttr ("IWGlobalNode.ExportNoteTrack" + $loop)`;
|
|
if ( `attributeExists ("AnimGroupColor" + $loop) "IWGlobalNode"` == 0)
|
|
{
|
|
addAttr -ln ("AnimGroupColor" + $loop) -dt "string" IWGlobalNode;
|
|
setAttr -type "string" ("IWGlobalNode.AnimGroupColor" + $loop) ("Red");
|
|
}
|
|
string $groupColor = `getAttr ("IWGlobalNode.AnimGroupColor" + $loop)`;
|
|
|
|
// Build the fields
|
|
rowLayout -nc 4 -columnWidth4 60 480 80 90;
|
|
checkBox ("Entry" + $loop);
|
|
textFieldButtonGrp -bc ("CODExporterFileBrowes " + $loop) -cc ("ChangeFileName " + $loop) -text $FileName -columnWidth2 450 30 -buttonLabel "..." ("FileNameTextField" + $loop);
|
|
intFieldGrp -cc ("ChangeFrameStart " + $loop) -v1 (`getAttr ("IWGlobalNode.FrameStart" + $loop)`) -numberOfFields 1 -columnWidth2 35 40 -label "Start" ("FrameStart" + $loop);
|
|
intFieldGrp -cc ("ChangeFrameEnd " + $loop) -v1 (`getAttr ("IWGlobalNode.FrameEnd" + $loop)`)-numberOfFields 1 -columnWidth2 35 40 -label "End" ("FrameEnd" + $loop);
|
|
setParent ..;
|
|
|
|
rowLayout -nc 1 -columnWidth1 725 ;
|
|
separator -w 725;
|
|
setParent ..;
|
|
|
|
rowLayout -nc 6 -columnWidth6 60 70 75 75 295 120;
|
|
text -width 60 -label "Group" -align "center" ("GroupColor" + $loop);
|
|
optionMenu -w 70 -changeCommand ( "SetGroupColor " + $loop ) ( "SetGroupOption" + $loop );
|
|
menuItem -label "Red";
|
|
menuItem -label "Green";
|
|
menuItem -label "Blue";
|
|
menuItem -label "Yellow";
|
|
menuItem -label "Purple";
|
|
menuItem -label "Orange";
|
|
optionMenu -e -value $groupColor ( "SetGroupOption" + $loop );
|
|
SetGroupColor $loop;
|
|
|
|
button -w 70 -label "Move Up" -c ("MoveAnimEntry Up " + $loop ) ("MoveEntryUp" + $loop);
|
|
button -w 70 -label "Move Down" -c ("MoveAnimEntry Down " + $loop ) ("MoveEntryDown" + $loop);
|
|
separator;
|
|
button -w 120 -label " Set To Timeline" -c ("SetAnimationTimeline " + $loop) ("SetAnimNumber" + $loop);
|
|
|
|
setParent ..;
|
|
|
|
rowLayout -nc 1 -columnWidth1 725 ;
|
|
separator -w 725;
|
|
setParent ..;
|
|
|
|
rowLayout -nc 5 -columnWidth5 70 110 95 110 110 ;
|
|
button -w 70 -label "Export nodes : " -c ("SelectListExportNodes " + $loop);
|
|
|
|
|
|
// Get the prefix of the exported asset
|
|
|
|
string $tokNodes[];
|
|
tokenize $ExportNodeCheck ":" $tokNodes;
|
|
|
|
// Check the export nodes list (read in above) to see if it needs setting.
|
|
if (`size $ExportNodeCheck`)
|
|
{
|
|
text -bgc 0.9 0.9 0.9 -label (" Prefix is " + $tokNodes[0] + ": ") ("ExportNodeCheck" + $loop);
|
|
}
|
|
else
|
|
{
|
|
text -bgc 1 0 0.7 -label " NO EXPORT NODES" ("ExportNodeCheck" + $loop);
|
|
}
|
|
|
|
button -label "Set Export Nodes" -c ("SetExportNodes " + $loop);
|
|
button -label "Select Export Nodes" -c ("SelectExportNodes " + $loop);
|
|
button -label "List Export Nodes" -c ("ListExportNodes " + $loop);
|
|
setParent ..;
|
|
|
|
rowLayout -nc 7 -cw 1 90 -cw 2 145 -cw 3 127 -cw 4 110 -cw 5 40 -cw 6 110 -cw 7 110 ;
|
|
button -w 90 -label "Add Note Track" -c ("SelectListNoteTrack " + $loop);
|
|
text -label (" " + $NoteTrack + " ") ("NoteTrackWindowText" + $loop);
|
|
|
|
// Calc the color for the note track
|
|
if ($NoteTrack == "NO NOTE TRACK" )
|
|
text -e -bgc 1 0 0.7 ("NoteTrackWindowText" + $loop);
|
|
else
|
|
text -e -bgc 0.9 0.9 0.9 ("NoteTrackWindowText" + $loop);
|
|
|
|
button -l "Add Selected NoteTrack";
|
|
button -l "Remove NoteTrack" -c ("RemoveNoteTrack " + $loop);
|
|
text -l "------";
|
|
|
|
// Build the gun selection list.
|
|
optionMenuGrp -label "Gun" -columnWidth 1 50 -columnWidth 2 120 -cc ("ChangeExportedGun " + $loop) ("AnimationExportGunMenu" + $loop);
|
|
|
|
// Get a list of all the loaded COD characters
|
|
string $CODChars[] = `ls ("*:*CODCharacterLocatorShape") ("*CODCharacterLocatorShape") `;
|
|
|
|
// Check a character was loaded
|
|
if (`size $CODChars` == 0)
|
|
{
|
|
// There are no COD chars loaded so ignore the gun selection
|
|
menuItem -label "Default Gun";
|
|
}
|
|
else
|
|
{
|
|
// A character is loaded so get the list of guns
|
|
int $GunNumber = `getAttr ($CODChars[0] + ".NumOfGun")`;
|
|
int $GunLoop;
|
|
string $GunName;
|
|
|
|
// Add the default gun setting first
|
|
menuItem -label "Default Gun";
|
|
|
|
for ($GunLoop = 0; $GunLoop < $GunNumber ; $GunLoop++ )
|
|
{
|
|
$GunName = `getAttr ($CODChars[0] + ".GunList" + $GunLoop)`;
|
|
menuItem -label $GunName;
|
|
}
|
|
|
|
// If gun number happens to be 0, change it to 1
|
|
|
|
int $getGunNum = `getAttr ("IWGlobalNode.GunNumber" + $loop)`;
|
|
if($getGunNum == 0)
|
|
{
|
|
setAttr ("IWGlobalNode.GunNumber" + $loop) 1;
|
|
}
|
|
|
|
|
|
// Set the correct gun in the menu. Dont forget to add 1 to skip the default gun
|
|
int $GunSelection = `getAttr ("IWGlobalNode.GunNumber" + $loop)`;
|
|
optionMenuGrp -e -sl $GunSelection ("AnimationExportGunMenu" + $loop);
|
|
}
|
|
setParent ..;
|
|
|
|
rowLayout -nc 1 -columnWidth1 725 ;
|
|
separator -w 725;
|
|
setParent ..;
|
|
|
|
rowLayout -nc 1 -columnWidth1 725 ;
|
|
separator -w 725;
|
|
setParent ..;
|
|
|
|
rowLayout -nc 1 -columnWidth1 725 ;
|
|
separator -w 725;
|
|
setParent ..;
|
|
}
|
|
|
|
|
|
|
|
global proc SetAnimationTimeline(int $animationNumber)
|
|
{
|
|
int $startFrame = `getAttr ("IWGlobalNode.FrameStart" + $animationNumber)`;
|
|
int $endFrame = `getAttr ("IWGlobalNode.FrameEnd" + $animationNumber)`;
|
|
|
|
playbackOptions -ast $startFrame -aet $endFrame -min $startFrame -max $endFrame;
|
|
currentTime $startFrame;
|
|
}
|
|
|
|
|
|
|
|
global proc MoveAnimEntry( string $direction, int $index )
|
|
{
|
|
int $animCount;
|
|
int $swapIndex;
|
|
|
|
$animCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
if ( $direction == "Up" )
|
|
{
|
|
if ( $index == 1 )
|
|
return;
|
|
|
|
$swapIndex = $index - 1;
|
|
}
|
|
|
|
if ( $direction == "Down" )
|
|
{
|
|
if ( $index == $animCount )
|
|
return;
|
|
|
|
$swapIndex = $index + 1;
|
|
}
|
|
|
|
// get all the attributes
|
|
string $fileName1 = `getAttr ("IWGlobalNode.FileName" + $index)`;
|
|
string $exportNode1 = `getAttr ("IWGlobalNode.ExportNodes" + $index)`;
|
|
string $exportNodeTrack1 = `getAttr ("IWGlobalNode.ExportNoteTrack" + $index)`;
|
|
int $frameStart1 = `getAttr ("IWGlobalNode.FrameStart" + $index)`;
|
|
int $frameEnd1 = `getAttr ("IWGlobalNode.FrameEnd" + $index)`;
|
|
int $gunNumber1 = `getAttr ("IWGlobalNode.GunNumber" + $index)`;
|
|
string $groupColor1 = `getAttr ("IWGlobalNode.AnimGroupColor" + $index)`;
|
|
|
|
string $fileName2 = `getAttr ("IWGlobalNode.FileName" + $swapIndex)`;
|
|
string $exportNode2 = `getAttr ("IWGlobalNode.ExportNodes" + $swapIndex)`;
|
|
string $exportNodeTrack2 = `getAttr ("IWGlobalNode.ExportNoteTrack" + $swapIndex)`;
|
|
int $frameStart2 = `getAttr ("IWGlobalNode.FrameStart" + $swapIndex)`;
|
|
int $frameEnd2 = `getAttr ("IWGlobalNode.FrameEnd" + $swapIndex)`;
|
|
int $gunNumber2 = `getAttr ("IWGlobalNode.GunNumber" + $swapIndex)`;
|
|
string $groupColor2 = `getAttr ("IWGlobalNode.AnimGroupColor" + $swapIndex)`;
|
|
|
|
// swap the attributes
|
|
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $swapIndex) $fileName1;
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $swapIndex) $exportNode1;
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $swapIndex) $exportNodeTrack1;
|
|
setAttr -type "string" ("IWGlobalNode.AnimGroupColor" + $swapIndex) $groupColor1;
|
|
setAttr ("IWGlobalNode.FrameStart" + $swapIndex) $frameStart1;
|
|
setAttr ("IWGlobalNode.FrameEnd" + $swapIndex) $frameEnd1;
|
|
setAttr ("IWGlobalNode.GunNumber" + $swapIndex) $gunNumber1;
|
|
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $index) $fileName2;
|
|
setAttr -type "string" ("IWGlobalNode.ExportNodes" + $index) $exportNode2;
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $index) $exportNodeTrack2;
|
|
setAttr -type "string" ("IWGlobalNode.AnimGroupColor" + $index) $groupColor2;
|
|
setAttr ("IWGlobalNode.FrameStart" + $index) $frameStart2;
|
|
setAttr ("IWGlobalNode.FrameEnd" + $index) $frameEnd2;
|
|
setAttr ("IWGlobalNode.GunNumber" + $index) $gunNumber2;
|
|
|
|
|
|
// set correct fields
|
|
textFieldButtonGrp -e -text $fileName2 ("FileNameTextField" + $index);
|
|
intFieldGrp -e -value1 $frameStart2 ("FrameStart" + $index );
|
|
intFieldGrp -e -value1 $frameEnd2 ("FrameEnd" + $index );
|
|
optionMenu -e -value $groupColor2 ( "SetGroupOption" + $index );
|
|
SetGroupColor $index;
|
|
optionMenuGrp -e -sl $gunNumber2 ("AnimationExportGunMenu" + $index);
|
|
if ($exportNodeTrack2 == "NO NOTE TRACK" )
|
|
text -e -bgc 1 0 0.7 -label (" " + $exportNodeTrack2 + " ") ("NoteTrackWindowText" + $index);
|
|
else
|
|
text -e -bgc 0.9 0.9 0.9 -label (" " + $exportNodeTrack2 + " ") ("NoteTrackWindowText" + $index);
|
|
text -e -en 0 ("NoteTrackWindowText" + $index);
|
|
text -e -en 1 ("NoteTrackWindowText" + $index);
|
|
|
|
|
|
// Get the prefix of the exported asset
|
|
|
|
string $tokNodes[];
|
|
tokenize $exportNode2 ":" $tokNodes;
|
|
|
|
if (`size $exportNode2`)
|
|
{
|
|
text -e -bgc 0.9 0.9 0.9 -label (" Prefix is " + $tokNodes[0] + ": ") ("ExportNodeCheck" + $index);
|
|
}
|
|
else
|
|
{
|
|
text -e -bgc 1 0 0.7 -label " NO EXPORT NODES" ("ExportNodeCheck" + $index);
|
|
}
|
|
|
|
|
|
text -e -en 0 ("ExportNodeCheck" + $index);
|
|
text -e -en 1 ("ExportNodeCheck" + $index);
|
|
|
|
textFieldButtonGrp -e -text $fileName1 ("FileNameTextField" + $swapIndex);
|
|
intFieldGrp -e -value1 $frameStart1 ("FrameStart" + $swapIndex );
|
|
intFieldGrp -e -value1 $frameEnd1 ("FrameEnd" + $swapIndex );
|
|
optionMenu -e -value $groupColor1 ( "SetGroupOption" + $swapIndex );
|
|
SetGroupColor $swapIndex;
|
|
optionMenuGrp -e -sl $gunNumber1 ("AnimationExportGunMenu" + $swapIndex);
|
|
if ($exportNodeTrack1 == "NO NOTE TRACK" )
|
|
text -e -bgc 1 0 0.7 -label (" " + $exportNodeTrack1 + " ") ("NoteTrackWindowText" + $swapIndex);
|
|
else
|
|
text -e -bgc 0.9 0.9 0.9 -label (" " + $exportNodeTrack1 + " ") ("NoteTrackWindowText" + $swapIndex);
|
|
text -e -en 0 ("NoteTrackWindowText" + $swapIndex);
|
|
text -e -en 1 ("NoteTrackWindowText" + $swapIndex);
|
|
|
|
|
|
// Get the prefix of the exported asset
|
|
|
|
if (`size $exportNode1`)
|
|
{
|
|
text -e -bgc 0.9 0.9 0.9 -label (" Prefix is " + $tokNodes[0] + ": ") ("ExportNodeCheck" + $swapIndex);
|
|
}
|
|
else
|
|
{
|
|
text -e -bgc 1 0 0.7 -label " NO EXPORT NODES" ("ExportNodeCheck" + $swapIndex);
|
|
}
|
|
|
|
text -e -en 0 ("ExportNodeCheck" + $swapIndex);
|
|
text -e -en 1 ("ExportNodeCheck" + $swapIndex);
|
|
|
|
}
|
|
|
|
|
|
global proc SetGroupColor( int $index )
|
|
{
|
|
string $groupColor;
|
|
$groupColor = `optionMenu -q -value ("SetGroupOption"+$index)`;
|
|
|
|
switch ( $groupColor )
|
|
{
|
|
case "Yellow":
|
|
text -e -bgc 0.9 0.9 0.1 ("GroupColor" + $index);
|
|
break;
|
|
|
|
case "Red":
|
|
text -e -bgc 0.9 0.1 0.1 ("GroupColor" + $index);
|
|
break;
|
|
|
|
case "Blue":
|
|
text -e -bgc 0.1 0.1 0.9 ("GroupColor" + $index);
|
|
break;
|
|
|
|
case "Green":
|
|
text -e -bgc 0.1 0.9 0.1 ("GroupColor" + $index);
|
|
break;
|
|
|
|
case "Orange":
|
|
text -e -bgc 1.0 0.5 0.0 ("GroupColor" + $index);
|
|
break;
|
|
|
|
case "Purple":
|
|
text -e -bgc 0.5 0.0 0.5 ("GroupColor" + $index);
|
|
break;
|
|
|
|
default:
|
|
text -e -bgc 0.5 0.5 0.5 ("GroupColor" + $index);
|
|
break;
|
|
|
|
}
|
|
|
|
setAttr -type "string" ("IWGlobalNode.AnimGroupColor" + $index) $groupColor;
|
|
|
|
text -e -en 0 ("GroupColor" + $index);
|
|
text -e -en 1 ("GroupColor" + $index);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ChangeExportedGun
|
|
//
|
|
// This proc updates the GunNumber varible when the value changes
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ChangeExportedGun (int $AnimNumber)
|
|
{
|
|
|
|
int $GunSelection = `optionMenuGrp -q -sl ("AnimationExportGunMenu" + $AnimNumber)`;
|
|
|
|
setAttr ("IWGlobalNode.GunNumber" + $AnimNumber) $GunSelection;
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ChangeFileName
|
|
//
|
|
// This proc updates the intFieldGrp varible when the value changes
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ChangeFileName (int $AnimNumber)
|
|
{
|
|
int $animCount;
|
|
int $animIndex;
|
|
string $changedFileName;
|
|
string $compareFileName;
|
|
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $AnimNumber) (`textFieldButtonGrp -q -text ("FileNameTextField" + $AnimNumber)`);
|
|
|
|
$changedFileName = `getAttr ("IWGlobalNode.FileName" + $AnimNumber)`;
|
|
|
|
$animCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
for ( $animIndex = 1; $animIndex <= $animCount; $animIndex++ )
|
|
{
|
|
if ( $animIndex != $AnimNumber )
|
|
{
|
|
$compareFileName = `getAttr ("IWGlobalNode.FileName" + $animIndex)`;
|
|
if ( $compareFileName == $changedFileName )
|
|
{
|
|
confirmDialog -title "Warning" -message "There are entries with duplicate export file names\nDuplicate file names are not allowed.";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ChangeFrameStart
|
|
//
|
|
// This proc updates the intFieldGrp varible when the value changes
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ChangeFrameStart (int $AnimNumber)
|
|
{
|
|
|
|
setAttr ("IWGlobalNode.FrameStart" + $AnimNumber) (`intFieldGrp -q -v1 ("FrameStart" + $AnimNumber)`);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: ChangeFrameEnd
|
|
//
|
|
// This proc updates the intFieldGrp varible when the value changes
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc ChangeFrameEnd (int $AnimNumber)
|
|
{
|
|
|
|
setAttr ("IWGlobalNode.FrameEnd" + $AnimNumber) (`intFieldGrp -q -v1 ("FrameEnd" + $AnimNumber)`);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: RemoveAnimationAttributes
|
|
//
|
|
// This procedure removes all the extra attributes from the IWGlobalNode for a animation file entry
|
|
// It is the reverse of AddAnimationAttributes
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc RemoveAnimationAttributes(int $AnimNumber)
|
|
{
|
|
|
|
// Attributes so far :
|
|
//
|
|
// FileName#
|
|
|
|
|
|
deleteAttr ("IWGlobalNode.FileName" + $AnimNumber);
|
|
|
|
deleteAttr ("IWGlobalNode.FrameStart" + $AnimNumber) ;
|
|
|
|
deleteAttr ("IWGlobalNode.FrameEnd" + $AnimNumber) ;
|
|
|
|
deleteAttr ("IWGlobalNode.ExportNodes" + $AnimNumber);
|
|
|
|
deleteAttr ("IWGlobalNode.ExportNoteTrack" + $AnimNumber);
|
|
|
|
deleteAttr ("IWGlobalNode.GunNumber" + $AnimNumber);
|
|
|
|
deleteAttr ("IWGlobalNode.AnimGroupColor" + $AnimNumber);
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: AddAnimationAttributes
|
|
//
|
|
// This procedure adds all the extra attributes to the IWGlobalNode for a new animation file
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc AddAnimationAttributes(int $AnimNumber)
|
|
{
|
|
|
|
// Attributes so far :
|
|
//
|
|
// FileName#
|
|
|
|
|
|
|
|
addAttr -ln ("FileName" + $AnimNumber) -dt "string" IWGlobalNode;
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $AnimNumber) ("Click on [...] button to locate the file");
|
|
|
|
addAttr -ln ("FrameStart" + $AnimNumber) -at long IWGlobalNode;
|
|
|
|
addAttr -ln ("FrameEnd" + $AnimNumber) -at long IWGlobalNode;
|
|
|
|
addAttr -ln ("ExportNodes" + $AnimNumber) -dt "string" IWGlobalNode;
|
|
|
|
addAttr -ln ("ExportNoteTrack" + $AnimNumber) -dt "string" IWGlobalNode;
|
|
setAttr -type "string" ("IWGlobalNode.ExportNoteTrack" + $AnimNumber) ("NO NOTE TRACK");
|
|
|
|
addAttr -ln ("GunNumber" + $AnimNumber) -at long IWGlobalNode;
|
|
setAttr ("IWGlobalNode.GunNumber" + $AnimNumber) 1;
|
|
|
|
addAttr -ln ("AnimGroupColor" + $AnimNumber) -dt "string" IWGlobalNode;
|
|
setAttr -type "string" ("IWGlobalNode.AnimGroupColor" + $AnimNumber) ("Red");
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: AddAnimation
|
|
//
|
|
// This procedure adds a animation to the list in the IWGlobalNode and re-draws the main window to make it visible
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc AddAnimation()
|
|
{
|
|
// Unlock the node to add an attribute
|
|
|
|
lockNode -lock off IWGlobalNode;
|
|
|
|
// Add 1 to the animation count attribute
|
|
|
|
int $AnimationCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
|
|
$AnimationCount ++;
|
|
|
|
setAttr IWGlobalNode.AnimationCount $AnimationCount;
|
|
|
|
// Add all the extra attributes to the IWGlobalNode for the new animation
|
|
|
|
AddAnimationAttributes $AnimationCount;
|
|
|
|
// add the new animation to the window so it's visible in the list
|
|
|
|
setParent AnimationListColumnLayout;
|
|
DisplayAnimationLine $AnimationCount;
|
|
|
|
|
|
// Relock the node to protect it
|
|
|
|
lockNode IWGlobalNode;
|
|
}
|
|
|
|
|
|
|
|
global proc SavePostExportConvertAnim()
|
|
{
|
|
string $convert;
|
|
$convert = `optionMenu -q -value animPostExportConvertMenu`;
|
|
setAttr -type "string" "IWGlobalNode.postExportConvert" $convert;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CreateCODExportWindow
|
|
//
|
|
// This procedure creates the window.
|
|
//
|
|
// IN: string $win - the name of the window that's getting created.
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc CreateCODExportWindow ( string $win )
|
|
{
|
|
|
|
// define the window;
|
|
window
|
|
-title "COD Export Window"
|
|
$win;
|
|
|
|
//create a columnLayout for the top level layout
|
|
|
|
|
|
|
|
scrollLayout ;
|
|
|
|
columnLayout -columnAttach "both" 5 -rowSpacing 10 -columnWidth 725 ExportMainLayout;
|
|
|
|
// Create a frame layout for the export list
|
|
|
|
frameLayout -label "Animation List" -borderStyle "etchedIn" -collapsable true -collapse false -p ExportMainLayout AnimationListFrameLayout;
|
|
|
|
//Create a column layout
|
|
|
|
columnLayout TopExportColLayout;
|
|
|
|
columnLayout -p TopExportColLayout AnimationListColumnLayout;
|
|
|
|
// Create the list of animations and there data
|
|
|
|
DisplayAnimationList;
|
|
|
|
// Create column layout for the export buttons
|
|
|
|
// columnLayout -p ExportMainLayout -rowSpacing 10 -columnWidth 500 ExportButtonColumnLayout;
|
|
|
|
rowColumnLayout -p TopExportColLayout -w 500 -columnWidth 1 200 -columnWidth 2 200 -cs 1 100 -cs 2 100 -numberOfColumns 2 ExporterButtonsLayout;
|
|
|
|
|
|
button -w 100 -label "Add New Entry" -p ExporterButtonsLayout AddAnimationButton;
|
|
|
|
button -w 150 -label "Delete Selected Entries" -p ExporterButtonsLayout DeleteSelectedButton;
|
|
|
|
separator -p ExporterButtonsLayout; separator -p ExporterButtonsLayout ;
|
|
|
|
button -w 150 -label "Export Selected Entries" -p ExporterButtonsLayout ExportSelectedButton;
|
|
|
|
button -w 150 -label "Export All Entries" -p ExporterButtonsLayout ExportAllButton;
|
|
|
|
button -label "Re-order Export Settings" -p ExporterButtonsLayout ReOrderButton;
|
|
|
|
optionMenu -cc "SavePostExportConvertAnim" animPostExportConvertMenu;
|
|
menuItem -label "Export Only";
|
|
menuItem -label "PC Convert";
|
|
menuItem -label "Xenon Convert";
|
|
|
|
if ( `attributeExists ( "postExportConvert" ) IWGlobalNode` > 0 )
|
|
{
|
|
string $convert;
|
|
$convert = `getAttr "IWGlobalNode.postExportConvert"`;
|
|
optionMenu -e -value $convert animPostExportConvertMenu;
|
|
}
|
|
else
|
|
{
|
|
addAttr -ln "postExportConvert" -dt "string" IWGlobalNode;
|
|
setAttr -type "string" "IWGlobalNode.postExportConvert" "Export Only";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CreateCODExportWindowCB
|
|
//
|
|
// This procedure sets up the callbacks for the buttons.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc CreateCODExportWindowCB ()
|
|
{
|
|
|
|
button -e -c AddAnimation AddAnimationButton;
|
|
|
|
button -e -c DeleteSelectedAnimations DeleteSelectedButton;
|
|
|
|
button -e -c ("StartTheExport 1") ExportSelectedButton;
|
|
|
|
button -e -c ("StartTheExport 0 ") ExportAllButton;
|
|
|
|
button -e -c ("source ReorderExports; ReorderExports; CODExportAnimationWindow") ReOrderButton;
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CODExportAnimationCheckReference
|
|
//
|
|
// Check each reference files if it is under C:\
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc CODExportAnimationCheckReference()
|
|
{
|
|
string $referenceFiles[];
|
|
string $driveLetter;
|
|
int $referenceFilesCount;
|
|
int $referenceFileIndex;
|
|
|
|
$referenceFiles = `file -q -reference`;
|
|
|
|
$referenceFilesCount = `size $referenceFiles`;
|
|
|
|
for( $referenceFileIndex = 0; $referenceFileIndex < $referenceFilesCount; $referenceFileIndex++ )
|
|
{
|
|
$driveLetter = `startString $referenceFiles[$referenceFileIndex] 1`;
|
|
if ( $driveLetter != "c" && $driveLetter != "C" )
|
|
error ("Reference file: [" + $referenceFiles[$referenceFileIndex] + "] needs to be under C:/." );
|
|
}
|
|
}
|
|
|
|
|
|
global proc UpdateXAnimExportPath()
|
|
{
|
|
int $animCount;
|
|
int $animIndex;
|
|
string $fileName;
|
|
|
|
if ( `attributeExists AnimationCount IWGlobalNode` == 0)
|
|
return;
|
|
|
|
$animCount = `getAttr IWGlobalNode.AnimationCount`;
|
|
if ($animCount < 1)
|
|
return;
|
|
|
|
for ($i = 1; $i <= $animCount; $i++)
|
|
{
|
|
$fileName=`getAttr ("IWGlobalNode.FileName" + $i)`;
|
|
$fileName = `substitute "C:/trees/cod2/" $fileName "C:/trees/cod3/cod3/"`;
|
|
setAttr -type "string" ("IWGlobalNode.FileName" + $i) $fileName;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
global proc createIWGlobalNodeAnimationProtect()
|
|
{
|
|
$iwGlobalNodeArray = `ls IWGlobalNode`;
|
|
if ( `size $iwGlobalNodeArray`)
|
|
{
|
|
|
|
// Lock the IWGlobalNode and then clear to have node deselected
|
|
|
|
lockNode IWGlobalNode;
|
|
select -cl;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
// PROC: CODExportAnimationWindow
|
|
//
|
|
// This script builds the export window
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
global proc CODExportAnimationWindow()
|
|
{
|
|
int $pluginLoaded;
|
|
string $iwGlobalNodeArray[];
|
|
|
|
// check if the plugin is loaded. If not, load it. If that fails, error out
|
|
$iwGlobalNodeArray = `ls IWGlobalNode`;
|
|
if ( `size $iwGlobalNodeArray` == 0 )
|
|
createNode "renderLayer" -n "IWGlobalNode";
|
|
|
|
// Check lockNode first
|
|
|
|
int $checkLockNode[];
|
|
$checkLockNode = `lockNode -q IWGlobalNode`;
|
|
|
|
if($checkLockNode[0])
|
|
{
|
|
// If it's locked, unlock to build the window
|
|
|
|
lockNode -lock off IWGlobalNode;
|
|
}
|
|
|
|
UpdateXAnimExportPath();
|
|
|
|
|
|
// Create a window
|
|
string $win = "CODExportWindow";
|
|
|
|
// check and see if the window exists. if it does, then delete it.
|
|
if (`window -exists $win`)
|
|
deleteUI $win;
|
|
|
|
CODExportAnimationCheckReference();
|
|
|
|
// create the window
|
|
CreateCODExportWindow $win;
|
|
|
|
// make the callbacks
|
|
CreateCODExportWindowCB;
|
|
|
|
// Protect the IWGlobalNode from being deleted
|
|
createIWGlobalNodeAnimationProtect();
|
|
|
|
// show the window
|
|
showWindow $win;
|
|
|
|
}
|
|
|