maya贴图路径找回脚本

/* This file downloaded from https://www.360docs.net/doc/403727847.html,

''

'' https://www.360docs.net/doc/403727847.html, File Information:

''

'' Script Name: FileTextureManager

'' Author:

'' Last Updated: Nov 18, 2008

'' Update/Change this file at:

'' https://www.360docs.net/doc/403727847.html,/maya/downloads/mel_scripts/rendering/misc/1012.html

''

'' Please do not alter any information above this line

'' it is generated dynamically by https://www.360docs.net/doc/403727847.html, and will

'' be changed automatically on any updates.

*/

///////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////

///

/// Procedure Name : FileTextureManager

///

/// Updated : July 10, 2007

/// In celebration of Hongkong's returning to China for ten years.

///

/// Author : Crow Yeh

/// Contact : crow@https://www.360docs.net/doc/403727847.html,

///

/// History :

/// v3.3 Fixed a bug that dselects needed file nodes when user checks

/// checkBoxes not supposed to be checked.

/// v3.2 Fixed a bug that fails to recognise '\' as path separator

/// under OS other than Windows.

/// Extra functions now supports mentalray.

/// v3.1 Adds support (only basic functions) for Maya

/// psdFileTex node type and mentalray mentalRayTexture

/// node type.

///

/// Description :

///

/// File Texture Manager works on Windows/IRIX/Linux/MAC, manages file textures in a handy way.

/// FTM's basic functions:

/// 1. Analyse scene file textures and give texture existence report.

/// 2. Copy or move the original texture files to user defined path (customizable).

/// 3. Update file textures' path info.

/// 4. Handle path strings. eg. replace string, add prefix, append suffix...

/// FTM's extra fuctions:

/// 1. Substitute file texture's path root string. eg. redirecting sourceiamges...

/// 2. Memory efficiency setup for textures. (BOT for Maya and .map for mentalray.)

/// 3. Filter type batch set.

/// 4. Texture file format conversion.

///

/// How to use :

///

/// Put the script in your scripts folder then start Maya. Type

/// and execute "FileTextureManager" in command line or Script

/// Editor, an UI window will appear. Then follow the help in the UI

/// window to finish your job. Have fun!

///

/// Inputs : None

///

/// Return : None

///

/// All Rights Reserved .

///////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////

///////////////////

// SCRIPT Starts //

///////////////////

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

//

// Procedure to check selection

//

proc int FTM_SelCheck(string $nodes[]){

int $sel = 0;

if (size($nodes))

$sel = 1;

else

confirmDialog -t "File Texture Manager" -m "At least one file texture node must be selected!" -b "OK";

return $sel;

}

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

// Procedure to remind user that job finished.

//

proc FTM_END(){

confirmDialog -t "File Texture Manager" -m "Job finished.\nRefer to Script Editor for details." -ma center -b "OK";

}

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

//

// Procedure to give logs

//

proc FTM_Log (string $type, string $node, string $log) {

string $finLog;

if (size($node))

$log = $node + "\n";

else

$log = "\t" + $log + "\n";

switch ($type) {

case "start":

$finLog = "\n**************************************************************************** ***********************************\n\

File Texture Manager Log starts...\n\

******************************************************************************* ********************************\n";

break;

case "end":

$finLog = "****************************************************************************** *********************************\n\

File Texture Manager Log ends...\n\

******************************************************************************* ********************************\n";

break;

default:

$finLog = $log;

break;

}

print $finLog;

}

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

//

// Get the right format of path(folder) to match current OS.

//

proc string FTM_GetPath (string $FTM_FileOrPath, string $FTM_OldPath)

//$FTM_FileOrPath Input type: file or path

//$FTM_OldPath The input

{

//Do not use 'fromNativePath' here

//that only works on Windows!

$FTM_OldPath = `substituteAll "\\\\" $FTM_OldPath "/"`;

//Only want the path.

if ($FTM_FileOrPath == "file")

$FTM_OldPath = `dirname $FTM_OldPath`;

//Get rid of the slash at the end.

$FTM_OldPath = `substitute "/*$" $FTM_OldPath ""`;

//Get the right path.

string $FTM_RightPath = `toNativePath ($FTM_OldPath + "/")`;

return $FTM_RightPath;

}

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

//

// Get the right format of input file's fullname (including path) to match current OS.

// Return a string array, the first element is the right format of the input file's

// fullname (including path), the second element is the shortname of input file (without path). //

proc string[] FTM_GetFile (string $FTM_OldFullPath)

{

string $FTM_RightPath[];

string $FTM_PathElements[];

int $FTM_PathElementsSize;

// fullname

$FTM_OldFullPath = `substituteAll "\\\\" $FTM_OldFullPath "/"`;

$FTM_RightPath[0] = `toNativePath $FTM_OldFullPath`;

$FTM_PathElementsSize = `tokenize $FTM_OldFullPath "/" $FTM_PathElements`;

$FTM_RightPath[1] = $FTM_PathElements[$FTM_PathElementsSize - 1];

return $FTM_RightPath;

}

/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////

//

// Analyse all the file texture nodes in current scene.

//

proc string[] FTM_FileTextureAnalyst ()

{

// All the file texture nodes maybe point to texture files in different paths(folders).

// Here I use "group" to indicate different paths , which means there are n "groups" of

// different paths if the file texture nodes point to files in n different paths.

// The trick is to have an string array $FTM_Groups[], within which every element has corresponding

// path and nodes pointing to that path are concatenated togather with a "*", which is not supposed to appear in path or name.

// Every element has a form style of "path*node1*node2*node3..."

// Leave $FTM_Groups[0] for empty path, which means node's texture file was not specified.

// Leave $FTM_Groups[1] for files without path, which means only texture file's short name was presented but path info was missing.

// All the file texture nodes found in current scene.

global string $lsCmd;

string $FTM_Files[] = eval($lsCmd);

// Different groups.

string $FTM_Groups[];

int $FTM_GroupsSize;

if (size($FTM_Files)){

$FTM_Groups[0] = "FTM_EmptySocket_FTM";

$FTM_Groups[1] = "FTM_MissingPathSocket_FTM";

}

// Figure out how many "groups" there are in current scene, and put each file texture node // into proper "group".

for ($eachFile in $FTM_Files)

{

$FTM_GroupsSize = size($FTM_Groups);

// Get the path of current file texture node

string $FTM_CurrentFullPath = substituteAll ("\\\\", `getAttr ($eachFile + ".fileTextureName")`, "/");

string $FTM_CurrentPath = dirname ($FTM_CurrentFullPath);

// File texutre was specified.

if (size($FTM_CurrentPath))

{

// Compare current path to all "groups" have been found. If matches then append current node

// to current "group" and exist the compare loop immediately.

// Remember that socket [0] is kept for nodes without texture file specified

// Remember that socket [1] is kept for nodes with texture file specified but with the path info missing

for ($j=2; $j<$FTM_GroupsSize; $j++)

{

string $buffer[];

tokenize $FTM_Groups[$j] "*" $buffer;

// Get the path of current "group".

string $FTM_OldPath = $buffer[0];

string $cmp1 = $FTM_CurrentPath;

string $cmp2 = $FTM_OldPath;

// Windows is not case sensitive to path

if (`about -nt`) {

$cmp1 = tolower($FTM_CurrentPath);

$cmp2 = tolower($FTM_OldPath);

}

// Compare current path to all "groups" have been found.

if ($cmp1 == $cmp2)

{

// Append current node to current group

string $tmp = $FTM_Groups[$j];

$tmp += "*" + $eachFile;

$FTM_Groups[$j] = $tmp;

break;

}

}

// No "group" matches means new "group" was found.

if ($j >= $FTM_GroupsSize)

{

// Create a new "group" and append current file texure node.

$FTM_Groups[$FTM_GroupsSize] = $FTM_CurrentPath + "*" + $eachFile;

continue;

}

}

// File texture was specified but the path info was missing

else if (size($FTM_CurrentFullPath)){

string $tmp = $FTM_Groups[1];

$tmp += "*" + $eachFile;

$FTM_Groups[1] = $tmp;

}

// File texture was not specified yet. Append current node to the first socket of groups

else{

string $tmp = $FTM_Groups[0];

$tmp += "*" + $eachFile;

$FTM_Groups[0] = $tmp;

}

}

select -cl;

return $FTM_Groups;

}

///////////////////////////////////////////////////////

///////////////////////////////////////////////////////

//

// Edit the UI Controls after they've been built

//

proc FTM_EditUIControl (string $FTM_OptionColumn, string $FTM_HelpForm)

{

// Operation mode

radioButtonGrp -e -on1 ("textFieldButtonGrp -e -en 0 -tx \"\" " + $FTM_OptionColumn + "|FTM_SourceDirectoryField")

-on2 ("textFieldButtonGrp -e -en 1 -tx \"\" " + $FTM_OptionColumn + "|FTM_SourceDirectoryField")

($FTM_OptionColumn + "|FTM_OperationMode");

// Set source directory

textFieldButtonGrp -e -bc ("FTM_BrowseCmd \"file\" \"" + $FTM_OptionColumn + "|FTM_SourceDirectoryField\" \"Set_S.D.\" 0")

($FTM_OptionColumn + "|FTM_SourceDirectoryField");

// Set target directory

textFieldButtonGrp -e -bc ("FTM_BrowseCmd \"path\" \"" + $FTM_OptionColumn + "|FTM_TargetDirectoryField\" \"Set_T.D.\" 4")

($FTM_OptionColumn + "|FTM_TargetDirectoryField");

// Make new folder

checkBoxGrp -e -on1 ("textFieldGrp -e -en 1 -text \"\" " + $FTM_OptionColumn + "|FTM_NewFolderNameField")

-of1 ("textFieldGrp -e -en 0 -text \"MyTextureFiles\" " + $FTM_OptionColumn + "|FTM_NewFolderNameField")

($FTM_OptionColumn + "|FTM_MakeFolderChecker");

// Add prefix

checkBox -e -onc ("textField -e -en 1 -text \"\" " + $FTM_OptionColumn + "|FTM_AddPrefixRow|FTM_PrefixField")

-ofc ("textField -e -en 0 -text \"prefix_\" " + $FTM_OptionColumn + "|FTM_AddPrefixRow|FTM_PrefixField")

($FTM_OptionColumn + "|FTM_AddPrefixRow|FTM_AddPrefixChecker");

// Add suffix

checkBox -e -onc ("textField -e -en 1 -text \"\" " + $FTM_OptionColumn +

"|FTM_AddSuffixRow|FTM_SuffixField")

-ofc ("textField -e -en 0 -text \"_suffix\" " + $FTM_OptionColumn + "|FTM_AddSuffixRow|FTM_SuffixField")

($FTM_OptionColumn + "|FTM_AddSuffixRow|FTM_AddSuffixChecker");

// Replace string

checkBoxGrp -e -on1 ("textFieldGrp -e -en 1 -text \"\" " + $FTM_OptionColumn + "|FTM_OldStringField; textFieldGrp -e -en 1 -text \"\" " + $FTM_OptionColumn + "|FTM_NewStringField")

-of1 ("textFieldGrp -e -en 0 -text \"OldString\" " + $FTM_OptionColumn + "|FTM_OldStringField; textFieldGrp -e -en 0 -text \"NewString\" " + $FTM_OptionColumn + "|FTM_NewStringField")

($FTM_OptionColumn + "|FTM_ReplaceStringChecker");

// Help description field

string $FTM_HelpDescription = "\n[Description]:\n";

$FTM_HelpDescription += " File Texture Manager works on Windows/IRIX/Linux/MAC, manages file textures in a very handy way.\n";

$FTM_HelpDescription += " FTM basic functions:\n";

$FTM_HelpDescription += " 1. Analyse scene file textures.\n";

$FTM_HelpDescription += " 2. Copy or move the original texture files to user defined path.\n";

$FTM_HelpDescription += " 3. Update file textures' path.\n";

$FTM_HelpDescription += " 4. Mentalray texture node is supported too.\n";

$FTM_HelpDescription += " FTM extra functions:\n";

$FTM_HelpDescription += " 1. Substitute file texture path's root string. eg. redirecting sourceiamges...\n";

$FTM_HelpDescription += " 2. Memory efficiency setup/unset for file textures according to their resolution. Textures larger than Threshold (in either x or y) will be set to use renderer prefered format (BOT for Maya and .map for mentalray) in setup mode. Corresponding memory-efficient file will be automatically generated if needed. When unset, all textures smaller than threshold in both x and y will be set to use normal textures, from which file the memory efficient texture was generated. BOT unset assume normal texture exist in the same directory. Mentalray .map unset will first check if the normal texture exist. If not, FTM will try to extract one from the .map file. Nodes pointing to sequences will be ignored.\n";

$FTM_HelpDescription += " 3. Set filter type to specified type for selected file nodes.\n";

$FTM_HelpDescription += " 4. Convert texture file format from \"From\" to \"To\" for selected file nodes. If \"From\" is not \"*\", only file nodes whose texture files format match \"From\" will be handled. For file nodes use image sequence as texture files, the range for conversion need to be specified, so only print out corresponding commands instead of really do the jobs. This function use Maya \"imgcvt\" and mentalray \"imf_copy\" ultility to do the conversion, so make sure them can be found in system executable path.\n\n";

$FTM_HelpDescription += "[Work Flow]:\n";

$FTM_HelpDescription += " Step 1. Analyse scene file textures.(optional)\n";

$FTM_HelpDescription += " Step 2. Select scene file textures (nodes) you want to manage by checking on the related checkers in the UI. You can also do this by your own method, Eg. select them in Hypershade.\n";

$FTM_HelpDescription += " Step 3. Set options as needed.\n";

$FTM_HelpDescription += " Step 4. Do copy, move or set by pressing related button.\n\n";

$FTM_HelpDescription += "[Tips]:\n";

$FTM_HelpDescription += " 1. Always keep 2 different version for each texture file. Eg. \"abc_LowRes.tga\" is in low resolution while \"abc_HighRes.tga\" is in high resolution. Do your job using low-res textures to speed the interactant. Just remember to use FileTextureManager to reset each file texture to point to the related high-res texture before rendering. (Add prefix, add suffix or even replace string.)\n";

$FTM_HelpDescription += " 2. The FileTextureManager's UI does not update dynamically like what Attribute Editor does, so it is better to re-analyse scene file textures each time you finish an FTM job. This is not necessary if you do not use the Analyse function at all.\n\n";

$FTM_HelpDescription += "[Notes]:\n";

$FTM_HelpDescription += " 1. Final target directory will be equal to target directory plus new folder, if user decide to make a new folder.\n";

$FTM_HelpDescription += " 2. Add suffix function has limitation on the texture file name. To be sure it work as desired, the file name must be in a regular format, Eg. \"filename.ext\", \"filename.[#...#].ext\", \"filename.ext.[#...#]\", etc.\n";

$FTM_HelpDescription += " 3. Add prfix, add suffix and replace string can be executed at the same time to each file texture. Replace string is caculated first, then add suffix, and add prefix last.\n";

$FTM_HelpDescription += " 4. It is highly recommended not to contain \".\" in prefix, suffix, old string and new string.\n";

$FTM_HelpDescription += " 5. Sometimes process fails. The reason may be various. The most possible reason could be one of or both the following two: a. Texture file is not found in the source directory; b. Permission denied on reading or writing or deleting.\n\n";

$FTM_HelpDescription += "[Details]:\n";

$FTM_HelpDescription += " 1. Analysing scene file textures let you know how many file textures there are in the scene, where there are, whether they exist or not, etc. It also allows user select all the texture files point to same path by only one simple click.\n";

$FTM_HelpDescription += " 2. How to choose operation mode depends on different source directory status. If file is there where it point to, use Automatic mode, otherwise use Manual mode.\n";

$FTM_HelpDescription += " 3. Other functions are pretty definite as marked in the UI.\n";

scrollField -e -text $FTM_HelpDescription ($FTM_HelpForm + "|FTM_HelpField");

}

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

//

// judge if the input string is format extension, sequence or just part of file basename //

proc int FTM_FCWhatIs(string $string)

{

int $isWhat;

// 0 - format extension

// 1 - sequence number

// 2 - nothing, is just file basename

// 3 - bot

global string $FTM_FCAllFormats[];

$string = tolower($string);

if (stringArrayCount($string,$FTM_FCAllFormats))

$isWhat = 0;

else if (size(match("[0-9]*",$string)) == size($string))

$isWhat = 1;

else if ($string == "bot")

$isWhat = 3;

else

$isWhat = 2;

return $isWhat;

}

////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////

//

// judge texture file format, only according to the possible extension name

//

proc string[] FTM_FCFileRegularName(string $file)

{

$file = substituteAll ("\\\\", $file, "/");

string $fileRegularName[] = stringToStringArray(basename($file,""),".");

// try to make it like below

// [0] - file name

// [1] - the sequency number if presented, or ""

// [2] - the extension if presented, or ""

string $fileName;

string $seqNum;

string $fileFormat;

switch (size($fileRegularName))

{

case 0: // sick!!!

break;

case 1:// only file name presented

$fileName = $fileRegularName[0];

break;

case 2:// the second/last element could be sequence number, format extension or nothing;

if (FTM_FCWhatIs($fileRegularName[1]) == 0)

{

$fileName = $fileRegularName[0];

$fileFormat = $fileRegularName[1];

}

else if (FTM_FCWhatIs($fileRegularName[1]) == 1)

{

$fileName = $fileRegularName[0];

$seqNum = $fileRegularName[1];

}

else // FTM_FCWhatIs($fileRegularName[1]) = 2, which means the second/last element is just part of file basename, sick!!!

$fileName = basename($file,"");

break;

default: // there are 3 or more pieces. consider the last 2 only.

string $lastPiece = $fileRegularName[size($fileRegularName)-1];

if (FTM_FCWhatIs($lastPiece) == 0)

{

$fileFormat = $lastPiece;

$fileName = basenameEx($file);

// strip the last piece to judge again

$lastPiece = $fileRegularName[size($fileRegularName)-2];

if (FTM_FCWhatIs($lastPiece) == 1)

{

$seqNum = $lastPiece;

$fileName = basenameEx($fileName);

}

}

else if (FTM_FCWhatIs($lastPiece) == 1)

{

$seqNum = $lastPiece;

$fileName = basenameEx($file);

// strip the last piece to judge again

$lastPiece = $fileRegularName[size($fileRegularName)-2];

if (FTM_FCWhatIs($lastPiece) == 0)

{

$fileFormat = $lastPiece;

$fileName = basenameEx($fileName);

}

}

else if (FTM_FCWhatIs($lastPiece) == 3) //bot

{

$fileFormat = $fileRegularName[size($fileRegularName)-2] + ".bot";

if (size($fileRegularName) == 3)

$fileName = $fileRegularName[0];

else

{

$lastPiece = $fileRegularName[size($fileRegularName)-3];

if (FTM_FCWhatIs($lastPiece) == 1)

{

$seqNum = $lastPiece;

$fileName = basenameEx(basenameEx(basenameEx($file)));

}

else

$fileName = basenameEx(basenameEx($file));

}

}

else // really sick!!!

$fileName = basename($file,"");

break;

}

$fileRegularName[0] = $fileName;

$fileRegularName[1] = $seqNum;

$fileRegularName[2] = $fileFormat;

return $fileRegularName;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////

//

// check string $inputString,replace the first (count backwards) matching string $targetPattern with string $newPattern

//

proc string FTM_FCSubstituteLastPattern(string $inputString, string $targetPattern, string $newPattern)

{

$inputString = substituteAll("\\\\", $inputString, "/");// avoid to handle "\" in the path

//strip everything behind the last string $targetPattern's existence

string $exp1 = "^.*" + $targetPattern + "+";

string $noTail = match($exp1,$inputString);

//replace the last $targetPattern in $noTail with $newPattern

string $exp2 = $targetPattern + "+$";

string $newNoEnd = substitute($exp2,$noTail,$newPattern);

//replace $noTail part in $inputString with $newNoEnd

// substitute all special characters

string $badChar[] = {"+",".","^","$","[","]","(",")"};

for ($char in $badChar)

$noTail = `substituteAllString $noTail $char ("\\"+$char)`;

string $exp3 = "^" + $noTail + "+";//take care of "\", so encode string.

string $outputString = substitute($exp3,$inputString,$newNoEnd);

$outputString = toNativePath($outputString);

return $outputString;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////

//

// to analyse the number of digits for input filename

//

proc int FTM_FCDigitsNumber(string $fileName)

{

string $fileRegularName[] = FTM_FCFileRegularName($fileName); $fileName = FTM_FCSubstituteLastPattern($fileName,$fileRegularName[1],"*"); string $filesInSeq[] = `getFileList -fs $fileName`;

int $digiNum = 0;

for ($i=0;$i

{

string $tmp[] = FTM_FCFileRegularName($filesInSeq[$i]);

if ($digiNum <= size($tmp[1]))

$digiNum = size($tmp[1]);

}

return $digiNum;

}

////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////

//

// the file format converter

//

proc FTM_FCGo(int $progressUI, string $sourceFormatUI, string $targetFormat, int $handleSeq, int $updatePath, int $removeOrig)

//int $progressUI - need progress UI; 0 - No UI for progress, which is designed for command line uses.

//string $sourceFormatUI - format convert from

//string $targetFormat - format convert to

//int $handleSeq - handle sequence textures; 0 - do not handle sequence textures.

//int $updatePath - update path info; 0 - do not update path info.

//int $removeOrig - remove original textures; 0 - do not remove original textures.

{

if (FTM_SelCheck(`ls -sl -typ file -typ mentalrayTexture`)) {// if (0)

waitCursor -state on;

FTM_Log "start" "" "";

// list for file nodes to be handled

string $fileNodesList[] = FTM_FCGetMatches($sourceFormatUI);

int $isSeq[];// if it is using an image sequence as texture

int $isOneOfSeq[];// if it is using only one image of a whole sequence as texture.

string $file;// current file to be converted

string $fileFC;// current file in suitable naming for FC use

string $fileUpdatePath;// current file in suitable naming for updatePath use

string $fileRemove;// current file in proper naming for removing

// build progress feedback only in UI mode

if ($progressUI) {

// base of progress feedback setup

int $progress = 0;

int $percentage = 0;

progressWindow -t "FTM Working..." -pr $progress -ii 1 -min 0 -max `size($fileNodesList)`;

}

// executes cooresponding commands for each file node specified.

// the core process.

for ($i=0;$i

FTM_Log "" ($fileNodesList[$i]+":") "";

// build progress feedback only in UI mode

if ($progressUI){

// Check if the dialog has been cancelled

if ( `progressWindow -q -ic` ){

FTM_Log "" "User cancelled." "";

break;

}

$progress = $i+1;

$percentage = $progress * (100/size($fileNodesList));

progressWindow -e -pr $progress -st ("Handling " + $fileNodesList[$i] + " ...... " + $percentage + "%");

}

$file = toNativePath(substituteAll("\\\\",`getAttr ($fileNodesList[$i] + ".fileTextureName")`,"/"));

$fileFC = $file;

$fileRemove = $file;

string $fileRegularName[] = FTM_FCFileRegularName($file);

string $isBOT = `match "bot" $fileRegularName[2]`;

if (size($isBOT)) {

FTM_Log "" "Texture file is a BOT file. Skipped!" "";

continue;

}

string $targetFile = FTM_FCSubstituteLastPattern($file,$fileRegularName[2],$targetFormat);

// it is bad that a file has no extension to indicate its format, so add one if needed.

if (!size($fileRegularName[2]))

$targetFile += "." + $targetFormat;

$fileUpdatePath = $targetFile;

string $cmp1,$cmp2;

$cmp1 = $fileUpdatePath;

$cmp2 = $fileRemove;

if (`about -nt`) {

$cmp1 = toNativePath(tolower($cmp1));

$cmp2 = toNativePath(tolower($cmp2));

}

// skip all process if the file node was already handled before.

if($cmp1 == $cmp2)

FTM_Log "" "" "This file node was already handled before. Process skipped.";

else{ //else (1)

$isSeq[$i] = 0;

$isOneOfSeq[$i] = 0;

if (`nodeType $fileNodesList[$i]` == "file" && size($fileRegularName[1])) {

if (`getAttr ($fileNodesList[$i] + ".useFrameExtension")`)

$isSeq[$i] = 1;

else

$isOneOfSeq[$i] = 1;

}

//commands to execute

int $isMR_c = 0; //create .map file

int $isMR_x = 0; //extract .map file

if ($fileRegularName[2] == "map" && $targetFormat != "map")

$isMR_x = 1;

else if ($fileRegularName[2] != "map" && $targetFormat == "map")

$isMR_c = 1;

string $cmdFC = "system(\"";

if ($isMR_c)

$cmdFC += "imf_copy -p -r";

else if ($isMR_x)

$cmdFC += "imf_copy";

else

$cmdFC += "imgcvt -t " + $targetFormat;

string $cmdUpdatePath = "setAttr -typ \"string\" " + $fileNodesList[$i] + ".fileTextureName ";

string $cmdRemoveOrig = "sysFile -del \"";

if (!$handleSeq && $isSeq[$i])

FTM_Log "" "" "Sequence was not selected to be handled. Skipped.";

else { //else (2)

// need to handle sequence textures

if ($handleSeq && $isSeq[$i]){

string $padding = "";

for ($j=0;$j

$padding += "@";

$targetFile = FTM_FCSubstituteLastPattern($targetFile,$fileRegularName[1],$padding);

$fileFC = FTM_FCSubstituteLastPattern($file,$fileRegularName[1],$padding);

$fileRemove = FTM_FCSubstituteLastPattern($file,$fileRegularName[1],"*");

//command for sequence

if (!$isMR_c && !$isMR_x)

$cmdFC += " -n startIn endIn stepIn -N startOut endOut stepOut";

}

$cmdFC += " \\\"" + encodeString($fileFC) + "\\\" \\\"" + encodeString($targetFile) + "\\\"";

if ($isMR_c || $isMR_x)

$cmdFC += " " + $targetFormat + "\")";

else

$cmdFC += "\")";

// only do the convertion when target file doesn't exist,

// or convertion has been done before for other file node that shares the same texture.

if (`file -q -ex $fileUpdatePath`)

FTM_Log "" "" "Convertion skipped. New format texture exists, maybe convertion has been done before.";

else{ //else (3)

if (!$isSeq[$i]){

// system feedback

string $cmdFCFeedback = eval($cmdFC);

if (size($cmdFCFeedback))

FTM_Log "" "" $cmdFCFeedback;

if (`file -q -ex $fileUpdatePath`)

FTM_Log "" "" ("Convertion succeeded. Converted from \"" + $fileFC + "\" to \"" + $targetFile + "\".");

else

FTM_Log "" "" "Convertion failed. Could be file permission problem, disk capacity problem or source texture is of unknown/unsupported format.";

}

else { // for sequence, only print out command to execute.

if (!$isMR_c && !$isMR_x)

FTM_Log "" "" ("Sequence specified. Command to execute (format conversion):" + $cmdFC);

else

FTM_Log "" "" "Sequence specified. Use \"imf_copy\" to convert your tetures. A simple loop might be needed.";

}

}// else (3)

// need to update path info

if ($updatePath) {// if (1)

$cmdUpdatePath += "\"" + encodeString(toNativePath($fileUpdatePath)) + "\";";

$cmdRemoveOrig += encodeString($fileRemove) + "\";";

if (!$isSeq[$i]){// if (2)

if (`file -q -ex $fileUpdatePath`){ // if (3)

if(catchQuiet(eval($cmdUpdatePath))) {

FTM_Log "" "" "WARNING: Attribute \"fileTextureName\" is locked/connected and can NOT be modified!";

FTM_Log "" "" "WARNING: Path updating failed. So

Original Texture Removing will not be done even if it was selected to.";

}

else {// else (3)

FTM_Log "" "" ("Path updating succeeded. Set to \"" + (toNativePath($fileUpdatePath)) + "\".");

// need to remove old textures

// only remove old textures when updatePath is selected and updating succeeds

if ($removeOrig){ //if (4)

if ($isOneOfSeq[$i])

FTM_Log "" "" "Only one file of a whole sequence is used as texture, no file in the sequence is supposed to be removed.";

else if (!$isSeq[$i]){ // else if (1)

if (!eval($cmdRemoveOrig))

FTM_Log "" "" "Original texture removing failed, could be file permission problem.";

else

FTM_Log "" "" ("Original texture removing succeeded. Removed \"" + $fileRemove + "\".");

} // else if (1)

} // if (4)

}// else (3)

} // if (3)

else

FTM_Log "" "" "Convertion failed, Path Updating and Original Texture Removing will not be done even if they were selected to.";

} // if (2)

// for sequence, only print out command to execute

else { //else (4)

FTM_Log "" "" ("Sequence specified. Command to execute (update path info):" + $cmdUpdatePath);

if ($removeOrig)

FTM_Log "" "" ("Sequence specified. Command to execute (remove original textures):" + $cmdRemoveOrig);

}// else (4)

} // if (1)

} //else (2)

} // else(1)

} // for loop (1)

// feedback ends

if (!size($fileNodesList))

FTM_Log "" "No texture is of specified format." "";

// build progress feedback only in UI mode

if ($progressUI){

// finish progress feed back

progressWindow -ep;

FTM_Log "end" "" "";

// job done

FTM_END;

}

waitCursor -state off;

} // if (0)

}

////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////

//

// analyse all possible file nodes to find out those match user's specification

//

global proc string[] FTM_FCGetMatches (string $formatUI)

{

string $fileNodesList[]; // list for file nodes to be handled

string $tmpNodesList[] = `ls -sl -typ file -typ mentalrayTexture`; // list for all (selected) file nodes, which need to be analyse.

if (`FTM_SelCheck $tmpNodesList`) {

string $tmpNode; // each single file node in the list

string $tmpFile; // file that $tmpNode point to.

string $format = `optionMenu -q -v $formatUI`;

if ($format!="*") {// format from specified, so only handle files with that format for ($tmpNode in $tmpNodesList) {

$tmpFile = `getAttr ($tmpNode + ".fileTextureName")`;

string $tmpFileRegularName[] = FTM_FCFileRegularName($tmpFile);

if (tolower($tmpFileRegularName[2]) == tolower($format))// extension matches, this file node need to be handled

$fileNodesList[size($fileNodesList)] = $tmpNode;

}

}

else // "*" was selected as format from, which means to handle all (selected) file nodes $fileNodesList = $tmpNodesList;

}

return $fileNodesList;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//

// info transfer, just to make sure FTM_FCGo can be run in command line.

//

global proc FTM_FCGatherInfo(string $FTM_ExtraFunctionColumn)

{

string $sourceFormatUI = $FTM_ExtraFunctionColumn + "|FTM_FCRow|FTM_FCSourceMenu";

string $targetFormat = `optionMenu -q -v ($FTM_ExtraFunctionColumn + "|FTM_FCRow|FTM_FCTargetMenu")`;

int $handleSeq = `checkBox -q -v ($FTM_ExtraFunctionColumn + "|FTM_SeqCheck")`;

int $updatePath = `checkBox -q -v ($FTM_ExtraFunctionColumn + "|FTM_UpdateCheck")`;

int $removeOrig = `checkBox -q -v ($FTM_ExtraFunctionColumn + "|FTM_RemoveCheck")`;

FTM_FCGo 1

$sourceFormatUI

$targetFormat

$handleSeq

$updatePath

$removeOrig;

}

//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////

//

// Command for Filter Setup

//

global proc FTM_FilterSetup(string $FTM_ExtraFunctionColumn)

{

string $Nodes[] = `ls -sl -typ file`;

if (`FTM_SelCheck $Nodes`) {

waitCursor -state on;

FTM_Log "start" "" "";

int $filterType = `optionMenu -q -sl ($FTM_ExtraFunctionColumn+"|FTM_FilterTypeRow|FTM_FilterTypeMenu")` -1;

string $filter = `optionMenu -q -v ($FTM_ExtraFunctionColumn+"|FTM_FilterTypeRow|FTM_FilterTypeMenu")`;

int $progress = 0;

int $percentage = 0;

progressWindow -t "FTM Working..." -pr $progress -ii 1 -min 0 -max `size $Nodes`;

for ($i=0;$i

FTM_Log "" ($Nodes[$i]+":") "";

if ( `progressWindow -q -ic` ){