You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1507 lines
56 KiB
Plaintext
1507 lines
56 KiB
Plaintext
/*
|
|
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
|
* its licensors.
|
|
*
|
|
* For complete copyright and license terms please see the LICENSE at the root of this
|
|
* distribution (the "License"). All use of this software is governed by the License,
|
|
* or, if provided, by the license below or the license accompanying this file. Do not
|
|
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
*
|
|
*/
|
|
|
|
/*!
|
|
Material Export.
|
|
*/
|
|
|
|
LumberyardMaterialLoadDependencies();
|
|
|
|
global proc LumberyardMaterialLoadDependencies()
|
|
{
|
|
eval("source cryMaterial.mel");
|
|
}
|
|
|
|
//! Get the name textField of a material group.
|
|
/*!
|
|
/param $groupIndex The index of the material group.
|
|
*/
|
|
proc string LumberyardToolGetMaterialGroupItemName(int $groupIndex)
|
|
{
|
|
return ("materialGroupItemName" + $groupIndex);
|
|
}
|
|
|
|
//! Get the name text field of a material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
proc string LumberyardToolGetMaterialItemName(int $groupIndex, int $materialIndex)
|
|
{
|
|
return ("materialItemName" + $groupIndex + "_" + $materialIndex);
|
|
}
|
|
|
|
//! Get the row of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
proc string LumberyardToolGetMaterialGroupItemRow(int $groupIndex)
|
|
{
|
|
return ("materialGroupItemRow" + $groupIndex);
|
|
}
|
|
|
|
//! Get the tree view row item of a material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
proc string LumberyardToolGetMateriaItemRow(int $groupIndex, int $materialIndex)
|
|
{
|
|
return ("materialItemRow" + $groupIndex + "_" + $materialIndex);
|
|
}
|
|
|
|
//! Get the check box of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
proc string LumberyardToolGetMaterialGroupItemCheckBoxName(int $groupIndex)
|
|
{
|
|
return ("materialGroupItemCheck" + $groupIndex);
|
|
}
|
|
|
|
// Get the optionMenu of physicalize type of a material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
proc string LumberyardGetMaterialItemPhysicalizeOptionMenu(int $groupIndex, int $materialIndex)
|
|
{
|
|
return ("materialItemPhysicalizeOptionMenu" + $groupIndex + "_" + $materialIndex);
|
|
}
|
|
|
|
//! Get the current text in the name text field of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
proc string LumberyardToolGetMaterialGroupItemNameValue(int $groupIndex)
|
|
{
|
|
return `textField -query -text (LumberyardToolGetMaterialGroupItemName($groupIndex))`;
|
|
}
|
|
|
|
//! Get the current text in the name text field of a material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
proc string LumberyardToolGetMaterialItemNameValue(int $groupIndex, int $materialIndex)
|
|
{
|
|
return `textField -query -text (LumberyardToolGetMaterialItemName($groupIndex, $materialIndex))`;
|
|
}
|
|
|
|
//! Set the text in the name text field of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
/param $value The text value to set.
|
|
*/
|
|
proc LumberyardToolSetMaterialGroupItemNameValue(int $groupIndex, string $value)
|
|
{
|
|
textField -edit -text $value (LumberyardToolGetMaterialGroupItemName($groupIndex));
|
|
}
|
|
|
|
//! Get the text in the name text field of a material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
/param $value The text value to set.
|
|
*/
|
|
proc LumberyardToolSetMaterialItemNameValue(int $groupIndex, int $materialIndex, string $value)
|
|
{
|
|
textField -edit -text $value (LumberyardToolGetMaterialItemName($groupIndex, $materialIndex));
|
|
}
|
|
|
|
//! Provide the material physicalized type strings for displaying in option menu.
|
|
/*!
|
|
/note In saved back-end data, the original physicalized type names are unchanged. It works correctly
|
|
since the mapping order of actual types is not changed.
|
|
*/
|
|
proc string LumberyardExportGetMaterialPhysicalizeEnumString()
|
|
{
|
|
return "No Physics:Default:Proxy No Draw:No Collide:Obstruct";
|
|
}
|
|
|
|
//! Get material partition name.
|
|
/*!
|
|
/note
|
|
Ensures that the partition exists, the export selection attribute exists,
|
|
and that it contains as many elements as there are material groups.
|
|
*/
|
|
proc string LumberyardToolsCreateMaterialPartitionIfNeeded()
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
|
|
if( !`objExists $partitionName` )
|
|
{
|
|
// Create a dummy set and add to new partition to avoid script warning. Remove the dummy set right after partition creation.
|
|
sets -name "dummySet1";
|
|
partition -name $partitionName "dummySet1";
|
|
partition -removeSet $partitionName "dummySet1";
|
|
delete "dummySet1";
|
|
}
|
|
|
|
if(!`attributeExists "shouldExportArray" $partitionName`)
|
|
{
|
|
addAttr -dataType Int32Array -longName "shouldExportArray" $partitionName;
|
|
}
|
|
|
|
return $partitionName;
|
|
}
|
|
|
|
//! Save checkBox values for material groups to material partition.
|
|
/*!
|
|
/param $checkBoxStates[] checkBox states of material groups.
|
|
*/
|
|
proc LumberyardToolSetMaterialExportSelections(int $checkBoxStates[])
|
|
{
|
|
string $partitionName = `LumberyardToolsCreateMaterialPartitionIfNeeded`;
|
|
|
|
string $attributeString = (size($checkBoxStates) + "");
|
|
|
|
for($i = 0; $i < size($checkBoxStates); $i++)
|
|
{
|
|
$attributeString += (" " + $checkBoxStates[$i]);
|
|
}
|
|
|
|
string $attributeName = ($partitionName + ".shouldExportArray");
|
|
string $commandString = "setAttr " + $attributeName + " -type Int32Array " + $attributeString;
|
|
eval($commandString);
|
|
}
|
|
|
|
//! Ensures that a checkBox value exists for all material groups.
|
|
proc string LumberyardToolEnsureCorrectMaterialGroupData()
|
|
{
|
|
string $partitionName = `LumberyardToolsCreateMaterialPartitionIfNeeded`;
|
|
|
|
string $materialGroups[] = `partition -query $partitionName`;
|
|
int $checkBoxStates[] = `getAttr ($partitionName + ".shouldExportArray")`;
|
|
int $needsStoring = false;
|
|
|
|
// If there is old data or if the data has been manipulated, set any missing groups to export by default.
|
|
while(size($checkBoxStates) < size($materialGroups))
|
|
{
|
|
$checkBoxStates[size($checkBoxStates)] = true;
|
|
$needsStoring = true;
|
|
}
|
|
|
|
if($needsStoring)
|
|
{
|
|
LumberyardToolSetMaterialExportSelections($checkBoxStates);
|
|
}
|
|
|
|
return $partitionName;
|
|
}
|
|
|
|
//! Save the selection state of a material group with updated value.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
/param $value The updated state of check box.
|
|
*/
|
|
proc LumberyardToolSetMaterialGroupExportSelection(int $groupIndex, int $value)
|
|
{
|
|
string $partitionName = `LumberyardToolEnsureCorrectMaterialGroupData`;
|
|
int $checkBoxValues[] = `getAttr ($partitionName + ".shouldExportArray")`;
|
|
|
|
$checkBoxValues[$groupIndex] = $value;
|
|
LumberyardToolSetMaterialExportSelections($checkBoxValues);
|
|
}
|
|
|
|
|
|
//! Get the saved selection states of all material groups.
|
|
proc int[] LumberyardToolGetMaterialGroupExportSelections()
|
|
{
|
|
string $partitionName = `LumberyardToolEnsureCorrectMaterialGroupData`;
|
|
int $checkBoxStates[] = `getAttr ($partitionName + ".shouldExportArray")`;
|
|
return $checkBoxStates;
|
|
}
|
|
|
|
//! Remove the saved selection state of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
/note This should only be called when the group is about to be removed.
|
|
*/
|
|
proc LumberyardToolRemoveMaterialGroupExportSelection(int $groupIndex)
|
|
{
|
|
string $partitionName = `LumberyardToolEnsureCorrectMaterialGroupData`;
|
|
int $checkBoxStates[] = `getAttr ($partitionName + ".shouldExportArray")`;
|
|
intArrayRemoveAtIndex($groupIndex, $checkBoxStates);
|
|
LumberyardToolSetMaterialExportSelections($checkBoxStates);
|
|
}
|
|
|
|
//! Ensure a custom export path attribute exists for a material group.
|
|
proc int LumberyardToolEnsureCorrectMaterialGroupCustomExportPath(string $materialGroup)
|
|
{
|
|
if(`objExists $materialGroup`)
|
|
{
|
|
if (!`attributeExists "customExportPath" $materialGroup`)
|
|
{
|
|
addAttr -dataType "string" -longName "customExportPath" $materialGroup;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//! Ensure a custom export path attribute exists for all material groups.
|
|
proc LumberyardToolEnsureAllCorrectMaterialGroupCustomExportPath()
|
|
{
|
|
string $partitionName = `LumberyardToolsCreateMaterialPartitionIfNeeded`;
|
|
|
|
string $materialGroups[] = `partition -query $partitionName`;
|
|
for ($materialGroup in $materialGroups)
|
|
{
|
|
LumberyardToolEnsureCorrectMaterialGroupCustomExportPath $materialGroup;
|
|
}
|
|
}
|
|
|
|
//! Get custom export path attribute value of a material group.
|
|
/*!
|
|
/param $materialGroup The material group name.
|
|
*/
|
|
proc string LumberyardToolGetMaterialGroupCustomExportPath(string $materialGroup)
|
|
{
|
|
string $path;
|
|
if (`LumberyardToolEnsureCorrectMaterialGroupCustomExportPath $materialGroup`)
|
|
{
|
|
$path = `getAttr ($materialGroup + ".customExportPath")`;
|
|
}
|
|
return $path;
|
|
}
|
|
|
|
//! Set custom export path of the selected material group using folder browser.
|
|
global proc LumberyardToolSetMaterialGroupCustomExportPathFromBrowser()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
if ($g_currentSelectedMaterialGroupId >= 0)
|
|
{
|
|
string $selectedGroup = `LumberyardToolGetMaterialGroupItemNameValue $g_currentSelectedMaterialGroupId`;
|
|
string $result[] = `LumberyardBrowseForPath "" "Set Custom Export Path"`;
|
|
if (`size($result)` == 1)
|
|
{
|
|
$folderPath = $result[0];
|
|
textField -edit -text $folderPath LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD;
|
|
setAttr -type "string" ($selectedGroup + ".customExportPath") $folderPath;
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Set custom export path of the selected material group by entering in path text field.
|
|
global proc LumberyardToolSetMaterialGroupCustomExportPathFromTextField()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
if ($g_currentSelectedMaterialGroupId >= 0)
|
|
{
|
|
string $selectedGroup = `LumberyardToolGetMaterialGroupItemNameValue $g_currentSelectedMaterialGroupId`;
|
|
string $folderPath = `textField -query -text LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD`;
|
|
$folderPath = `cryExportFixupPath $folderPath`;
|
|
setAttr -type "string" ($selectedGroup + ".customExportPath") $folderPath;
|
|
}
|
|
}
|
|
|
|
//! Get custom export path of the selected material group from saved data.
|
|
global proc string LumberyardToolGetSelectedMaterialGroupCustomExportPath()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
if ($g_currentSelectedMaterialGroupId >= 0)
|
|
{
|
|
string $selectedGroup = `LumberyardToolGetMaterialGroupItemNameValue $g_currentSelectedMaterialGroupId`;
|
|
return `LumberyardToolGetMaterialGroupCustomExportPath $selectedGroup`;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
//! Are there existing material groups in partition.
|
|
global proc int LumberyardToolMaterialGroupsExist()
|
|
{
|
|
string $partitionName = `LumberyardToolsCreateMaterialPartitionIfNeeded`;
|
|
string $materialGroups[] = `partition -query $partitionName`;
|
|
int $materialGroupCount = `size $materialGroups`;
|
|
return $materialGroupCount > 0;
|
|
}
|
|
|
|
//! Consolidate all materials contained in groups into first group
|
|
/*!
|
|
/param $groups[] List of groups to consolidate into first group
|
|
*/
|
|
global proc string LumberyardMaterialConsolidateGroups(string $groups[])
|
|
{
|
|
string $consolidatedGroup = "";
|
|
int $groupCount = `size($groups)`;
|
|
|
|
if ($groupCount > 0 )
|
|
{
|
|
$consolidatedGroup = $groups[0];
|
|
for( $i = 1; $i < $groupCount; $i++ )
|
|
{
|
|
string $shaders[] = `sets -query $groups[$i]`;
|
|
cryMaterialRemoveShadersFromGroup $groups[$i] $shaders;
|
|
sets -addElement $consolidatedGroup $shaders;
|
|
delete $groups[$i];
|
|
}
|
|
cryMaterialRebuildGroup $consolidatedGroup;
|
|
}
|
|
return $consolidatedGroup;
|
|
}
|
|
|
|
//! Collects an array of groups that currently contain an element in shaderList
|
|
/*!
|
|
/param $existingGroups[] Result list of groups that have one of the shaders in it
|
|
/param $shaderList[] Shaders to look for in existing groups
|
|
*/
|
|
global proc LumberyardMaterialCollectExistingGroupsThatContain(string $existingGroups[], string $shaderList[])
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
string $materialGroups[];
|
|
$materialGroups = `cryMaterialGetMaterialGroups $partitionName`;
|
|
for( $materialGroup in $materialGroups )
|
|
{
|
|
for ( $shader in $shaderList)
|
|
{
|
|
if( `sets -isMember $materialGroup $shader` )
|
|
{
|
|
$existingGroups[`size($existingGroups)`] = $materialGroup;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Create a material group.
|
|
/*!
|
|
/param $name The material group name.
|
|
*/
|
|
global proc string LumberyardMaterialCreateGroup(string $name)
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
if(!`objExists $partitionName` )
|
|
{
|
|
partition -name $partitionName;
|
|
}
|
|
|
|
int $defaultName = 0;
|
|
if(`size($name)` == 0 )
|
|
{
|
|
$name = `cryMaterialGetDefaultGroupName`;
|
|
$defaultName = 1;
|
|
}
|
|
|
|
$newSet = `sets -empty -name $name`;
|
|
if( $defaultName == 0 && $newSet != $name )
|
|
{
|
|
confirmDialog -title "Create Group" -message ("The group was renamed from `" + $name + "` to `" + $newSet + "` due to a name clash.") -button "OK";
|
|
}
|
|
partition -add $partitionName $newSet;
|
|
LumberyardToolEnsureCorrectMaterialGroupCustomExportPath $newSet;
|
|
return $newSet;
|
|
}
|
|
|
|
//! Export the selected material groups to specified material export path.
|
|
/*!
|
|
/param $selectedGroups[] Selected material groups to export.
|
|
/param $customFilePath Specified material export path.
|
|
/param $showDialogs A flag controls whether to show dialogues for overwrite warnings and how many files are exported.
|
|
*/
|
|
global proc LumberyardExportSelectedMaterials(string $selectedGroups[], string $customFilePath, int $showDialogs)
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
if (!`objExists $partitionName`)
|
|
{
|
|
partition -name $partitionName;
|
|
}
|
|
|
|
// Prepare material partition by overwriting it with only selected material groups.
|
|
string $cryMaterialGroups[] = `partition -query $partitionName`;
|
|
for ($group in $cryMaterialGroups)
|
|
{
|
|
partition -removeSet $partitionName $group;
|
|
}
|
|
for ($group in $selectedGroups)
|
|
{
|
|
partition -addSet $partitionName $group;
|
|
}
|
|
|
|
// Do exporting work.
|
|
cryExportGenerateMaterialFileToFilePath 0 $customFilePath $showDialogs;
|
|
|
|
// Restore the original(all) material groups to material partition.
|
|
for ($group in $selectedGroups)
|
|
{
|
|
partition -removeSet $partitionName $group;
|
|
}
|
|
for ($group in $cryMaterialGroups)
|
|
{
|
|
partition -addSet $partitionName $group;
|
|
}
|
|
}
|
|
|
|
//! Gather selected materials from Hypershade or selected meshes to a string array
|
|
global proc string[] LumberyardMaterialGatherMaterialsFromGeom()
|
|
{
|
|
string $collectedMaterials[];
|
|
string $set = `sets -empty`;
|
|
if(`objExists $set`)
|
|
{
|
|
string $selected[];
|
|
$selected = `ls -sl`;
|
|
|
|
for($rootNode in $selected)
|
|
{
|
|
LumberyardMaterialGatherMaterialsFromGeomRecurse $set $rootNode;
|
|
}
|
|
|
|
//cryMaterialGetGroupShaders handles shaders and materials as equivalent
|
|
$collectedMaterials = `cryMaterialGetGroupShaders $set`;
|
|
delete $set;
|
|
}
|
|
return $collectedMaterials;
|
|
}
|
|
|
|
//! Gather materials from geometry recursively
|
|
/*!
|
|
/param $set Name of the collection set.
|
|
/param $node Root node of recursive search
|
|
*/
|
|
global proc LumberyardMaterialGatherMaterialsFromGeomRecurse( string $set, string $node )
|
|
{
|
|
string $shaderEngines[] = `listConnections -type shadingEngine $node`;
|
|
for( $shaderEngine in $shaderEngines )
|
|
{
|
|
string $shaders[] = `listConnections -type lambert $shaderEngine`;
|
|
for( $shader in $shaders )
|
|
{
|
|
if( `sets -isMember $set $shader` )
|
|
{
|
|
continue;
|
|
}
|
|
sets -forceElement $set $shader;
|
|
}
|
|
string $hwShaders[] = `listConnections -type hwShader $shaderEngine`;
|
|
for( $hwShader in $hwShaders )
|
|
{
|
|
if( `sets -isMember $set $hwShader` )
|
|
{
|
|
continue;
|
|
}
|
|
sets -forceElement $set $hwShader;
|
|
}
|
|
}
|
|
|
|
string $children[];
|
|
string $child;
|
|
$children = `listRelatives -children -fullPath $node`;
|
|
for ($child in $children)
|
|
{
|
|
LumberyardMaterialGatherMaterialsFromGeomRecurse $set $child;
|
|
}
|
|
}
|
|
|
|
//! Add materials from string list to a material group.
|
|
/*!
|
|
/param $materialList List of Materials to be added to group
|
|
/param $destGroup Name of destination group in partition
|
|
*/
|
|
global proc LumberyardMaterialAssignToPartitionGroup(string $materialList[], string $destinationGroup)
|
|
{
|
|
if(`objExists $destinationGroup`)
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
|
|
for ($material in $materialList)
|
|
{
|
|
cryMaterialMoveShaderToGroupWithPartition $destinationGroup $material $partitionName;
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Save the selection state of a material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
global proc LumberyardToolUpdateMaterialGroupCheckbox(int $groupIndex)
|
|
{
|
|
string $checkBoxName = `LumberyardToolGetMaterialGroupItemCheckBoxName $groupIndex`;
|
|
int $value = `checkBox -query -value $checkBoxName`;
|
|
LumberyardToolSetMaterialGroupExportSelection($groupIndex, $value);
|
|
}
|
|
|
|
//! Create a tree view item of a material group item and add it to the tree view.
|
|
/*!
|
|
/param $groupItem The material group name.
|
|
/param $groupIndex The material group index.
|
|
/param $shouldExport The export selection state of the group.
|
|
*/
|
|
proc LumberyardToolAddGroupItemToMaterialTreeView(string $groupItem, int $groupIndex, int $shouldExport)
|
|
{
|
|
global int $g_rowItemHeight;
|
|
|
|
setParent LUMBERYARDTOOL_MATERIAL_TREEVIEW;
|
|
string $rowFullName = `rowLayout -numberOfColumns 3 -columnWidth3 22 225 19
|
|
-height $g_rowItemHeight -columnAttach3 "left" "left" "left" -columnOffset3 4 0 4
|
|
(LumberyardToolGetMaterialGroupItemRow($groupIndex))`;
|
|
{
|
|
string $checkBoxName = `LumberyardToolGetMaterialGroupItemCheckBoxName $groupIndex`;
|
|
checkBox -label "" -value $shouldExport -backgroundColor 0.5 0.5 0.5 -changeCommand ("LumberyardToolUpdateMaterialGroupCheckbox " + $groupIndex) $checkBoxName;
|
|
textField -text $groupItem -width 225 -changeCommand ("LumberyardToolSetMaterialGroupName " + $groupIndex)
|
|
-alwaysInvokeEnterCommandOnReturn 1 -noBackground 1
|
|
-receiveFocusCommand ("LumberyardToolMaterialTreeViewGroupItemOnFocus " + $groupIndex)
|
|
`LumberyardToolGetMaterialGroupItemName $groupIndex`;
|
|
button -label "X" -backgroundColor 0 0 0 -height 20 -command("LumberyardToolRemoveMaterialGroup " + $groupIndex);
|
|
}
|
|
|
|
scriptJob -replacePrevious -nodeDeleted $groupItem "LumberyardToolUpdateMaterialTreeView" -parent $rowFullName;
|
|
}
|
|
|
|
//! Create a tree view item of a material and add it to the tree view.
|
|
/*!
|
|
/param $item The material group name.
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The material index within the group.
|
|
*/
|
|
proc string LumberyardToolAddMaterialItemToMaterialTreeView(string $item, int $groupIndex, int $materialIndex)
|
|
{
|
|
global int $g_rowItemHeight;
|
|
global float $g_UIColor[];
|
|
|
|
setParent LUMBERYARDTOOL_MATERIAL_TREEVIEW;
|
|
string $rowFullName = `rowLayout -numberOfColumns 3 -columnWidth3 137 110 19
|
|
-height $g_rowItemHeight -columnAttach3 "right" "left" "left" -columnOffset3 3 0 4
|
|
-dragCallback materialItemDragCallback -dropCallback materialItemDropCallback
|
|
(LumberyardToolGetMateriaItemRow($groupIndex, $materialIndex))`;
|
|
{
|
|
textField -text $item -width 100 -changeCommand ("LumberyardToolSetMaterialName " + $groupIndex + " " + $materialIndex)
|
|
-alwaysInvokeEnterCommandOnReturn 1 -noBackground 1
|
|
-receiveFocusCommand ("LumberyardToolMaterialTreeViewMaterialItemOnFocus " + $groupIndex + " " + $materialIndex)
|
|
`LumberyardToolGetMaterialItemName $groupIndex $materialIndex`;
|
|
optionMenu -label "" -width 110 -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-changeCommand ("LumberyardSetMaterialPhysicalizeType " + $groupIndex + " " + $materialIndex)
|
|
(LumberyardGetMaterialItemPhysicalizeOptionMenu($groupIndex, $materialIndex));
|
|
{
|
|
string $enumString = `LumberyardExportGetMaterialPhysicalizeEnumString`;
|
|
string $tokens[];
|
|
$numTokens = `tokenize $enumString ":" $tokens`;
|
|
for ($i = 0; $i < $numTokens; $i++)
|
|
{
|
|
menuItem -label $tokens[$i];
|
|
}
|
|
LumberyardUpdateMaterialTreeViewItemPhysicalizeType $groupIndex $materialIndex;
|
|
}
|
|
button -label "X" -backgroundColor 0 0 0 -height 20 -command("LumberyardToolRemoveMaterial " + $groupIndex + " " + $materialIndex);
|
|
}
|
|
|
|
scriptJob -replacePrevious -nodeDeleted $item "LumberyardToolUpdateMaterialTreeView" -parent $rowFullName;
|
|
|
|
return $rowFullName;
|
|
}
|
|
|
|
//! Create instruction texts for Material export list and add it
|
|
global proc LumberyardToolAddMaterialInstructionTexts()
|
|
{
|
|
global int $g_instructionRowSpace;
|
|
|
|
setParent LUMBERYARDTOOL_MATERIAL_TREEVIEW;
|
|
rowColumnLayout -numberOfRows 2 -rowOffset 1 "top" 70 -columnOffset 1 "both" 62 -rowSpacing 2 $g_instructionRowSpace;
|
|
text -label "Select a mesh or material and click `Add Material`";
|
|
text -label "or create a new material group by clicking `Add Group`";
|
|
}
|
|
|
|
//! Check if the materials added to the group contain Maya default material "lambert1". Inform user if found and remove it from the list.
|
|
/*!
|
|
/param $group Name of material group
|
|
/param $materials Materials added to the group
|
|
*/
|
|
global proc string[] LumberyardToolCheckDefaultMaterial(string $materials[])
|
|
{
|
|
string $filteredMaterials[];
|
|
int $messageShown = false;
|
|
for ($material in $materials)
|
|
{
|
|
if ($material == "lambert1")
|
|
{
|
|
if (!$messageShown)
|
|
{
|
|
string $message = "The Maya default material lambert1 cannot be added, please create a new " +
|
|
"material in the Hypershade and assign it to the meshes/faces that use lambert1.";
|
|
confirmDialog -title "Error occurred in adding materials to material group"
|
|
-message $message -button "OK" -defaultButton "OK" -cancelButton "OK";
|
|
$messageShown = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$filteredMaterials[`size $filteredMaterials`] = $material;
|
|
}
|
|
}
|
|
return $filteredMaterials;
|
|
}
|
|
|
|
//! Create a new material group and add selected materials, if any.
|
|
global proc LumberyardToolAddNewMaterialGroup()
|
|
{
|
|
LumberyardToolAddMaterials( false );
|
|
}
|
|
|
|
//! Create a new material group and add selected materials, if any.
|
|
global proc LumberyardToolAddMaterials( int $useExistingGroups)
|
|
{
|
|
string $materials[] = `LumberyardMaterialGatherMaterialsFromGeom`;
|
|
int $createEmptySet = (`size($materials)` == 0);
|
|
//Remove Lambert shaders
|
|
$materials = `LumberyardToolCheckDefaultMaterial $materials`;
|
|
|
|
//if the group contained only the default material, do not create the group.
|
|
if (`size ($materials)` == 0 && !$createEmptySet )
|
|
{
|
|
return;
|
|
}
|
|
|
|
string $destinationGroup = "";
|
|
|
|
if ($useExistingGroups)
|
|
{
|
|
string $existingGroups[];
|
|
LumberyardMaterialCollectExistingGroupsThatContain $existingGroups $materials;
|
|
//find existing groups that are involved and combine them.
|
|
//If no existing groups are involved then destinationGroup will be "".
|
|
$destinationGroup = `LumberyardMaterialConsolidateGroups $existingGroups`;
|
|
}
|
|
|
|
if ($destinationGroup == "")
|
|
{
|
|
// make a new group
|
|
string $groupName = "new_matGroup";
|
|
if (`size($materials)` > 0)
|
|
{
|
|
$groupName = $materials[0] + "_matGroup";
|
|
}
|
|
$destinationGroup = `LumberyardMaterialCreateGroup $groupName`;
|
|
}
|
|
|
|
//At this point the materials have not been added, only existing groups have been combined if expected
|
|
//materials that are currently not in the group will be added.
|
|
LumberyardAddMaterialPhysicalizeTypes $materials;
|
|
LumberyardMaterialAssignToPartitionGroup($materials, $destinationGroup);
|
|
select -clear;
|
|
//if user decided not to move materials and group ends up empty
|
|
if ((`sets -query -size $destinationGroup` == 0) && !$createEmptySet )
|
|
{
|
|
cryMaterialDeleteGroup $destinationGroup;
|
|
return;
|
|
}
|
|
|
|
LumberyardToolUpdateMaterialTreeView;
|
|
}
|
|
|
|
//! Create a new material under a specific material group.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material will add to.
|
|
*/
|
|
global proc LumberyardToolAddNewMaterial(int $groupIndex)
|
|
{
|
|
string $groupName = `LumberyardToolGetMaterialGroupItemNameValue $groupIndex`;
|
|
string $materials[] = `LumberyardMaterialGatherMaterialsFromGeom`;
|
|
select -clear;
|
|
$materials = `LumberyardToolCheckDefaultMaterial $materials`;
|
|
LumberyardAddMaterialPhysicalizeTypes $materials;
|
|
LumberyardMaterialAssignToPartitionGroup($materials, $groupName);
|
|
LumberyardToolUpdateMaterialTreeView;
|
|
}
|
|
|
|
//! Remove a specific material group.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
global proc LumberyardToolRemoveMaterialGroup(int $groupIndex)
|
|
{
|
|
string $group = `LumberyardToolGetMaterialGroupItemNameValue $groupIndex`;
|
|
string $materials[] = `cryMaterialGetGroupShaders $group`;
|
|
LumberyardRemoveMaterialPhysicalizeTypes $materials;
|
|
cryMaterialDeleteGroup $group;
|
|
LumberyardToolRemoveMaterialGroupExportSelection($groupIndex);
|
|
LumberyardToolUpdateMaterialTreeView;
|
|
}
|
|
|
|
//! Remove a material from a material group.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardToolRemoveMaterial(int $groupIndex, int $materialIndex)
|
|
{
|
|
string $group = `LumberyardToolGetMaterialGroupItemNameValue $groupIndex`;
|
|
string $materials[];
|
|
$materials[0] = `LumberyardToolGetMaterialItemNameValue $groupIndex $materialIndex`;
|
|
LumberyardRemoveMaterialPhysicalizeTypes $materials;
|
|
cryMaterialRemoveShadersFromGroup $group $materials;
|
|
LumberyardToolUpdateMaterialTreeView;
|
|
}
|
|
|
|
//! Get the material group name from its index.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
global proc string LumberyardToolGetMaterialGroupNameFromItemId(int $groupIndex)
|
|
{
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
if(`objExists $partitionName`)
|
|
{
|
|
string $materialGroups[];
|
|
$materialGroups = `partition -query $partitionName`;
|
|
if ($groupIndex < `size($materialGroups)`)
|
|
{
|
|
return $materialGroups[$groupIndex];
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
//! Get the material name from its group index and its index within the group.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The material index within the group.
|
|
*/
|
|
global proc string LumberyardToolGetMaterialNameFromItemId(int $groupIndex, int $materialIndex)
|
|
{
|
|
string $groupName = `LumberyardToolGetMaterialGroupNameFromItemId $groupIndex`;
|
|
if ($groupName != "")
|
|
{
|
|
string $contents[] = `cryMaterialGetGroupShaders $groupName`;
|
|
if ($materialIndex < `size($contents)`)
|
|
{
|
|
return $contents[$materialIndex];
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
//! Rename the material group with the value retrieved from its corresponding name textField.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
global proc LumberyardToolSetMaterialGroupName(int $groupIndex)
|
|
{
|
|
string $currentMaterialGroupName = `LumberyardToolGetMaterialGroupNameFromItemId $groupIndex`;
|
|
string $newMaterialGroupName = `LumberyardToolGetMaterialGroupItemNameValue $groupIndex`;
|
|
$newMaterialGroupName = `LumberyardVerifySceneObjectRequestName $newMaterialGroupName $currentMaterialGroupName`;
|
|
$currentMaterialGroupName = `rename $currentMaterialGroupName $newMaterialGroupName`;
|
|
// In case Maya adjusts the name for its own validity check (possible), update the widget to reflect the latest name.
|
|
LumberyardToolSetMaterialGroupItemNameValue $groupIndex $currentMaterialGroupName;
|
|
}
|
|
|
|
//! Rename the material name with the new name retrieved from the name text field.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardToolSetMaterialName(int $groupIndex, int $materialIndex)
|
|
{
|
|
string $currentMaterialName = `LumberyardToolGetMaterialNameFromItemId $groupIndex $materialIndex`;
|
|
string $newMaterialName = `LumberyardToolGetMaterialItemNameValue $groupIndex $materialIndex`;
|
|
$newMaterialName = `LumberyardVerifySceneObjectRequestName $newMaterialName $currentMaterialName`;
|
|
$currentMaterialName = `rename $currentMaterialName $newMaterialName`;
|
|
// In case Maya adjusts the name for its own validity check (possible), update the widget to reflect the latest name.
|
|
LumberyardToolSetMaterialItemNameValue $groupIndex $materialIndex $currentMaterialName;
|
|
}
|
|
|
|
//! Utility function to determine if a material should be set to ProxyNoDraw physicalize properties by default
|
|
/*!
|
|
/param $material Name of the material to set default physicalize flags for
|
|
*/
|
|
proc int LumberyardIsDefaultProxyNoDraw(string $material)
|
|
{
|
|
if(`objExists $material` && `attributeExists "lumberyardPhysMaterial" $material`)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if(`gmatch $material "*[Pp]hys*"`)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//! Add physicalize attribute to the materials.
|
|
/*!
|
|
/param $materials The materials that need to add physicalize attribute.
|
|
*/
|
|
global proc LumberyardAddMaterialPhysicalizeTypes(string $materials[])
|
|
{
|
|
for ($material in $materials)
|
|
{
|
|
if (!`attributeExists "physicalise" $material`)
|
|
{
|
|
cryExportAddEnumAttribute $material "physicalise" `cryExportGetMaterialPhysicalizeEnumString`;
|
|
}
|
|
|
|
if (LumberyardIsDefaultProxyNoDraw($material))
|
|
{
|
|
// ProxyNoDraw = 2
|
|
setAttr ($material + ".physicalise") 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Remove physicalize attribute from the materials.
|
|
/*!
|
|
/param $materials The materials that need to remove physicalize attribute.
|
|
/note
|
|
We need to remove the physicalize attribute from material when we remove the material from a group
|
|
so that in the future, when the material is added again to a group, its physicalize attribute will
|
|
be recreated and its default value is "None".
|
|
*/
|
|
global proc LumberyardRemoveMaterialPhysicalizeTypes(string $materials[])
|
|
{
|
|
for ($material in $materials)
|
|
{
|
|
if (`attributeExists "physicalise" $material`)
|
|
{
|
|
deleteAttr -attribute "physicalise" $material;
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Set the physicalize attribute of a material from optionMenu selection.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardSetMaterialPhysicalizeType(int $groupIndex, int $materialIndex)
|
|
{
|
|
string $materialName = `LumberyardToolGetMaterialNameFromItemId $groupIndex $materialIndex`;
|
|
int $newType = (`optionMenu -query -select (LumberyardGetMaterialItemPhysicalizeOptionMenu($groupIndex, $materialIndex))` - 1);
|
|
setAttr ($materialName + ".physicalise") $newType;
|
|
}
|
|
|
|
//! Update the optionMenu selection for the physicalize attribute of a material item.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardUpdateMaterialTreeViewItemPhysicalizeType(int $groupIndex, int $materialIndex)
|
|
{
|
|
string $materialName = `LumberyardToolGetMaterialNameFromItemId $groupIndex $materialIndex`;
|
|
if (`attributeExists "physicalise" $materialName`)
|
|
{
|
|
int $currentType =(`getAttr ($materialName + ".physicalise")` + 1);
|
|
optionMenu -edit -select $currentType `LumberyardGetMaterialItemPhysicalizeOptionMenu $groupIndex $materialIndex`;
|
|
}
|
|
}
|
|
|
|
// Current number of material groups.
|
|
global int $g_materialGroupItemCount = 0;
|
|
|
|
// Current number of materials.
|
|
global int $g_materialItemCount = 0;
|
|
|
|
// All tree view material item rows.
|
|
global string $g_materialItemRows[];
|
|
|
|
// Full names of all material rows. This is used for drag and drop operations.
|
|
global string $g_materialItemRowFullNames[];
|
|
|
|
// Text fields of all materials.
|
|
global string $g_materialItemNames[];
|
|
|
|
// Number of materials in each material group.
|
|
global int $g_materialInGroupNums[];
|
|
|
|
//! Update material tree view with the current material group settings.
|
|
global proc LumberyardToolUpdateMaterialTreeView()
|
|
{
|
|
global int $g_materialGroupItemCount;
|
|
global int $g_materialItemCount;
|
|
global string $g_materialItemRows[];
|
|
global string $g_materialItemRowFullNames[];
|
|
global string $g_materialItemNames[];
|
|
global int $g_materialInGroupNums[];
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
global string $g_addMaterialButton;
|
|
|
|
// For updating selected item.
|
|
string $selectedItem = `LumberyardToolMaterialGetSelectedItem`;
|
|
$g_currentSelectedMaterialGroupId = -1;
|
|
LumberyardSetSelectedMaterialGlobalId -1 -1;
|
|
//
|
|
string $childItems[] = `scrollLayout -query -childArray LUMBERYARDTOOL_MATERIAL_TREEVIEW`;
|
|
for ($child in $childItems)
|
|
{
|
|
deleteUI $child;
|
|
}
|
|
|
|
string $partitionName = `cryMaterialGetPartitionName`;
|
|
string $materialGroups[];
|
|
if (!`objExists $partitionName`)
|
|
{
|
|
// Create a dummy set and add to new partition to avoid script warning. Remove the dummy set right after partition creation.
|
|
sets -name "dummySet1";
|
|
partition -name $partitionName "dummySet1";
|
|
partition -removeSet $partitionName "dummySet1";
|
|
delete "dummySet1";
|
|
}
|
|
$materialGroups = `partition -query $partitionName`;
|
|
$g_materialGroupItemCount = `size($materialGroups)`;
|
|
$g_materialItemCount = 0;
|
|
|
|
if (size($materialGroups) == 0)
|
|
{
|
|
LumberyardToolAddMaterialInstructionTexts;
|
|
return;
|
|
}
|
|
|
|
int $checkBoxStates[] = `LumberyardToolGetMaterialGroupExportSelections`;
|
|
|
|
for ($i = 0; $i < $g_materialGroupItemCount; $i++)
|
|
{
|
|
if (`objExists $materialGroups[$i]`)
|
|
{
|
|
setParent LUMBERYARDTOOL_MATERIAL_TREEVIEW;
|
|
|
|
LumberyardToolAddGroupItemToMaterialTreeView $materialGroups[$i] $i $checkBoxStates[$i];
|
|
// For updating selected item.
|
|
if ($selectedItem == $materialGroups[$i])
|
|
{
|
|
$g_currentSelectedMaterialGroupId = $i;
|
|
LumberyardToolMaterialSetHighLightRow `LumberyardToolGetMaterialGroupItemRow $g_currentSelectedMaterialGroupId`;
|
|
}
|
|
//
|
|
string $contents[] = `cryMaterialGetGroupShaders $materialGroups[$i]`;
|
|
$g_materialInGroupNums[$i] = size($contents);
|
|
for ($j = 0; $j < `size($contents)`; $j++)
|
|
{
|
|
string $materialName = `cryMaterialUIShaderNameEncode $materialGroups[$i] $contents[$j]`;
|
|
$materialName = `cryMaterialUIShaderNameDecode $materialName`;
|
|
$g_materialItemRowFullNames[$g_materialItemCount] = `LumberyardToolAddMaterialItemToMaterialTreeView $materialName $i $j`;
|
|
// For updating selected item.
|
|
$g_materialItemRows[$g_materialItemCount] = `LumberyardToolGetMateriaItemRow $i $j`;
|
|
$g_materialItemNames[$g_materialItemCount] = `LumberyardToolGetMaterialItemName $i $j`;
|
|
if ($selectedItem == $materialName)
|
|
{
|
|
LumberyardSetSelectedMaterialGlobalId $i $g_materialItemCount;
|
|
LumberyardToolMaterialSetHighLightRow $g_materialItemRows[$g_materialItemCount];
|
|
}
|
|
//
|
|
$g_materialItemCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($g_currentSelectedMaterialGroupId == -1)
|
|
{
|
|
button -edit -enable false $g_addMaterialButton;
|
|
}
|
|
}
|
|
|
|
//! Export checked material groups.
|
|
/*!
|
|
/param $showDialogs A flag controls whether to show a confirmation dialogue about how many files are exported.
|
|
*/
|
|
global proc LumberyardToolExportCheckedMaterialGroups(int $showDialogs)
|
|
{
|
|
global int $g_materialGroupItemCount;
|
|
|
|
string $selectedGroups[];
|
|
int $selectedId = 0;
|
|
for ($i = 0; $i < $g_materialGroupItemCount; $i++)
|
|
{
|
|
if (`checkBox -query -value (LumberyardToolGetMaterialGroupItemCheckBoxName($i))`)
|
|
{
|
|
string $selectedGroup = `LumberyardToolGetMaterialGroupItemNameValue $i`;
|
|
if (`objExists $selectedGroup`)
|
|
{
|
|
$selectedGroups[$selectedId] = $selectedGroup;
|
|
$selectedId++;
|
|
}
|
|
}
|
|
}
|
|
LumberyardToolUpdateMaterialExportPath;
|
|
string $folderPath = `cryExportGetExportSettingValue "customMaterialFilePath"`;
|
|
LumberyardExportSelectedMaterials $selectedGroups $folderPath $showDialogs;
|
|
}
|
|
|
|
//! Set material export path.
|
|
global proc LumberyardToolUpdateMaterialExportPath()
|
|
{
|
|
global string $g_defaultPathString;
|
|
string $folderPath = `textField -query -text LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD`;
|
|
|
|
// For empty path, make sure UI is updated
|
|
if($folderPath == "")
|
|
{
|
|
LumberyardUtilitiesSetTextToDefaultPath("LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD");
|
|
}
|
|
// For default path, make sure empty string is passed to data backend
|
|
else if(`gmatch $folderPath $g_defaultPathString` == 1)
|
|
{
|
|
$folderPath = "";
|
|
}
|
|
else
|
|
{
|
|
$folderPath = `cryExportFixupPath $folderPath`;
|
|
textField -edit -text $folderPath LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD;
|
|
}
|
|
cryExportSetExportSettingValue "customMaterialFilePath" $folderPath;
|
|
}
|
|
|
|
//! Set material export path by browsing folder.
|
|
global proc LumberyardToolSetMaterialExportPathFromFileBrowser()
|
|
{
|
|
string $result[] = `LumberyardBrowseForPath "" "Set Material Export Path"`;
|
|
string $folderPath;
|
|
if (size($result) == 1)
|
|
{
|
|
$folderPath = `cryExportFixupPath $result[0]`;
|
|
textField -edit -text $folderPath LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD;
|
|
LumberyardToolUpdateMaterialExportPath;
|
|
}
|
|
}
|
|
|
|
//! Get material export path from saved back-end data.
|
|
proc string LumberyardToolGetMaterialExportPath()
|
|
{
|
|
global string $g_defaultPathString;
|
|
string $filePath = `cryExportGetExportSettingValue "customMaterialFilePath"`;
|
|
|
|
if($filePath == "")
|
|
{
|
|
$filePath = $g_defaultPathString;
|
|
}
|
|
|
|
return $filePath;
|
|
}
|
|
|
|
// Selected material group index.
|
|
global int $g_currentSelectedMaterialGroupId = -1;
|
|
|
|
// Selected material global index by considering materials from all groups.
|
|
global int $g_currentSelectedMaterialId = -1;
|
|
|
|
// The index of the owner group of the selected material.
|
|
global int $g_currentSelectedMaterialOwnerGroupId = -1;
|
|
|
|
//! Record the current selected material global index and the index of the material group that owns that material.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardSetSelectedMaterialGlobalId(int $groupIndex, int $materialIndex)
|
|
{
|
|
global int $g_currentSelectedMaterialId;
|
|
global int $g_currentSelectedMaterialOwnerGroupId;
|
|
$g_currentSelectedMaterialId = $materialIndex;
|
|
$g_currentSelectedMaterialOwnerGroupId = $groupIndex;
|
|
}
|
|
|
|
//! Highlight specific item row in material tree view.
|
|
/*!
|
|
/param $rowName Name of the item row to highlight.
|
|
*/
|
|
global proc LumberyardToolMaterialSetHighLightRow(string $rowName)
|
|
{
|
|
global float $g_highLightColor[];
|
|
rowLayout -edit -backgroundColor $g_highLightColor[0] $g_highLightColor[1] $g_highLightColor[2] $rowName;
|
|
}
|
|
|
|
//! Record the current selected material group item.
|
|
/*!
|
|
/param $groupIndex The material group index.
|
|
*/
|
|
global proc LumberyardToolMaterialTreeViewGroupItemOnFocus(int $groupIndex)
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
global int $g_materialGroupItemCount;
|
|
global int $g_materialItemCount;
|
|
global string $g_materialItemRows[];
|
|
global string $g_addMaterialButton;
|
|
|
|
$g_currentSelectedMaterialGroupId = $groupIndex;
|
|
LumberyardSetSelectedMaterialGlobalId -1 -1;
|
|
|
|
// Highlight selected material group item.
|
|
for ($i = 0; $i < $g_materialGroupItemCount; $i++)
|
|
{
|
|
if ($i == $groupIndex)
|
|
{
|
|
LumberyardToolMaterialSetHighLightRow `LumberyardToolGetMaterialGroupItemRow $i`;
|
|
}
|
|
else
|
|
{
|
|
rowLayout -edit -backgroundColor 0 0 0 `LumberyardToolGetMaterialGroupItemRow $i`;
|
|
}
|
|
}
|
|
for ($i = 0; $i < $g_materialItemCount; $i++)
|
|
{
|
|
rowLayout -edit -backgroundColor 0 0 0 $g_materialItemRows[$i];
|
|
}
|
|
|
|
button -edit -enable true $g_addMaterialButton;
|
|
LumberyardToolUpdateMaterialAdvancedOptionsFrame;
|
|
}
|
|
|
|
//! Record the current selected material item.
|
|
/*!
|
|
/param $groupIndex The index of the material group that the material belongs to.
|
|
/param $materialIndex The index of the material within the group.
|
|
*/
|
|
global proc LumberyardToolMaterialTreeViewMaterialItemOnFocus(int $groupIndex, int $materialIndex)
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
global int $g_materialGroupItemCount;
|
|
global int $g_materialItemCount;
|
|
global string $g_materialItemRows[];
|
|
global string $g_addMaterialButton;
|
|
|
|
$g_currentSelectedMaterialGroupId = -1;
|
|
|
|
// Highlight selected material item.
|
|
for ($i = 0; $i < $g_materialGroupItemCount; $i++)
|
|
{
|
|
rowLayout -edit -backgroundColor 0 0 0 `LumberyardToolGetMaterialGroupItemRow $i`;
|
|
}
|
|
for ($i = 0; $i < $g_materialItemCount; $i++)
|
|
{
|
|
if ($g_materialItemRows[$i] == `LumberyardToolGetMateriaItemRow $groupIndex $materialIndex`)
|
|
{
|
|
LumberyardToolMaterialSetHighLightRow $g_materialItemRows[$i];
|
|
LumberyardSetSelectedMaterialGlobalId $groupIndex $i;
|
|
}
|
|
else
|
|
{
|
|
rowLayout -edit -backgroundColor 0 0 0 $g_materialItemRows[$i];
|
|
}
|
|
}
|
|
|
|
button -edit -enable false $g_addMaterialButton;
|
|
LumberyardToolUpdateMaterialAdvancedOptionsFrame;
|
|
}
|
|
|
|
//! Get the item name on focus from material tree view.
|
|
global proc string LumberyardToolMaterialGetSelectedItem()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
global int $g_currentSelectedMaterialId;
|
|
global string $g_materialItemNames[];
|
|
|
|
if ($g_currentSelectedMaterialGroupId >= 0)
|
|
{
|
|
if (`textField -exists (LumberyardToolGetMaterialGroupItemName($g_currentSelectedMaterialGroupId))`)
|
|
return `LumberyardToolGetMaterialGroupItemNameValue $g_currentSelectedMaterialGroupId`;
|
|
}
|
|
else if ($g_currentSelectedMaterialId >= 0)
|
|
{
|
|
if (`textField -exists $g_materialItemNames[$g_currentSelectedMaterialId]`)
|
|
{
|
|
return `textField -query -text $g_materialItemNames[$g_currentSelectedMaterialId]`;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
//! View the selected material or material group item in Hypershade panel.
|
|
global proc LumberyardToolOpenSelectedInHyperShade()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
global int $g_currentSelectedMaterialId;
|
|
global string $g_materialItemNames[];
|
|
|
|
if ($g_currentSelectedMaterialGroupId >= 0)
|
|
{
|
|
string $currentSelectedMaterialGroupName = `LumberyardToolGetMaterialGroupItemName $g_currentSelectedMaterialGroupId`;
|
|
string $currentSelectedMaterialGroup = `textField -query -text $currentSelectedMaterialGroupName`;
|
|
select -replace -noExpand $currentSelectedMaterialGroup;
|
|
cryMaterialUIOpenHyperShader;
|
|
}
|
|
else if ($g_currentSelectedMaterialId >= 0)
|
|
{
|
|
string $currentSelectedMaterialName = $g_materialItemNames[$g_currentSelectedMaterialId];
|
|
string $currentSelectedMaterial = `textField -query -text $currentSelectedMaterialName`;
|
|
select $currentSelectedMaterial;
|
|
cryMaterialUIOpenHyperShader;
|
|
}
|
|
else
|
|
{
|
|
confirmDialog -title "Material" -message ("No material or material group is selected.") -button "OK";
|
|
}
|
|
}
|
|
|
|
//! Callback function when a material item gets dragged.
|
|
/*!
|
|
/param $dragControl The material item row being dragged.
|
|
/param $x The local x coordinate of the drag material item row.
|
|
/param $y The local y coordinate of the drag material item row.
|
|
/param $mods Flag indicating whether CTRL and/or SHIFT keys are pressed.
|
|
*/
|
|
global proc string[] materialItemDragCallback(string $dragControl, int $x, int $y, int $mods)
|
|
{
|
|
string $ret[];
|
|
// Simply return.
|
|
return $ret;
|
|
}
|
|
|
|
//! Repopulate the material item list under a material group item.
|
|
/*!
|
|
/param $groupIndex the index of the material group.
|
|
*/
|
|
global proc LumberyardMaterialUpdateMaterialItemList(int $groupIndex)
|
|
{
|
|
string $groupItem = `LumberyardToolGetMaterialGroupItemNameValue $groupIndex`;
|
|
string $contents[] = `cryMaterialGetGroupShaders $groupItem`;
|
|
for ($i = 0; $i < size($contents); $i++)
|
|
{
|
|
string $materialName = `cryMaterialUIShaderNameEncode $groupItem $contents[$i]`;
|
|
$materialName = `cryMaterialUIShaderNameDecode $materialName`;
|
|
textField -edit -text $materialName `LumberyardToolGetMaterialItemName $groupIndex $i`;
|
|
LumberyardUpdateMaterialTreeViewItemPhysicalizeType $groupIndex $i;
|
|
}
|
|
}
|
|
|
|
//! Callback function when a material item gets dropped.
|
|
/*!
|
|
/param $dragControl The material item row being dragged.
|
|
/param $dropControl The material item row being dropped.
|
|
/param $msgs[] User defined message type.
|
|
/param $x The local x coordinate of the drop material item row.
|
|
/param $y The local y coordinate of the drop material item row.
|
|
/param $type Type of operation: values of 1 == Move, 2 == Copy, 3 == Link.
|
|
*/
|
|
global proc materialItemDropCallback(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type)
|
|
{
|
|
global string $g_materialItemRowFullNames[];
|
|
global string $g_materialItemNames[];
|
|
global int $g_materialItemCount;
|
|
global int $g_materialInGroupNums[];
|
|
global int $g_materialGroupItemCount;
|
|
global int $dragRowId = -1;
|
|
global int $dropRowId = -1;
|
|
global int $g_rowItemHeight;
|
|
|
|
// Get the global material index for both drag and drop material items.
|
|
for ($i = 0; $i < $g_materialItemCount; $i++)
|
|
{
|
|
if ($g_materialItemRowFullNames[$i] == $dragControl)
|
|
{
|
|
$dragRowId = $i;
|
|
}
|
|
if ($g_materialItemRowFullNames[$i] == $dropControl)
|
|
{
|
|
$dropRowId = $i;
|
|
}
|
|
}
|
|
|
|
if ($dragRowId >= 0 && $dropRowId >= 0 && $dragRowId != $dropRowId)
|
|
{
|
|
int $moveGroupId = -1;
|
|
int $sum = 0;
|
|
for ($i = 0; $i < $g_materialGroupItemCount; $i++)
|
|
{
|
|
$sum += $g_materialInGroupNums[$i];
|
|
if ($sum > $dragRowId && $sum > $dropRowId)
|
|
{
|
|
$moveGroupId = $i;
|
|
break;
|
|
}
|
|
// If the materials corresponding to the rowLayouts are members of
|
|
// different groups, do not move the material.
|
|
else if ($sum > $dragRowId || $sum > $dropRowId)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($moveGroupId >= 0)
|
|
{
|
|
int $moveSteps = $dropRowId - $dragRowId;
|
|
if ($y < ($g_rowItemHeight / 2))
|
|
{
|
|
if ($moveSteps > 0)
|
|
{
|
|
$moveSteps -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ($moveSteps < 0)
|
|
{
|
|
$moveSteps += 1;
|
|
}
|
|
}
|
|
|
|
if ($moveSteps != 0)
|
|
{
|
|
string $currentGroup = `LumberyardToolGetMaterialGroupItemNameValue $moveGroupId`;
|
|
string $currentMaterials[];
|
|
$currentMaterials[0] = `textField -query -text $g_materialItemNames[$dragRowId]`;
|
|
|
|
if ($moveSteps < 0)
|
|
{
|
|
while ($moveSteps < 0)
|
|
{
|
|
cryMaterialMoveShadersUp $currentGroup $currentMaterials;
|
|
$moveSteps++;
|
|
}
|
|
}
|
|
else if ($moveSteps > 0)
|
|
{
|
|
while ($moveSteps > 0)
|
|
{
|
|
cryMaterialMoveShadersDown $currentGroup $currentMaterials;
|
|
$moveSteps--;
|
|
}
|
|
}
|
|
|
|
LumberyardMaterialUpdateMaterialItemList $moveGroupId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Add a new material under the selected material group.
|
|
global proc LumberyardAddNewMaterialToGroup()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
LumberyardToolAddNewMaterial $g_currentSelectedMaterialGroupId;
|
|
}
|
|
|
|
//! Necessary setup when the Lumberyard Tool is loaded or the scene file is changed.
|
|
global proc LumberyardMaterialOnLoad()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
$g_currentSelectedMaterialGroupId = -1;
|
|
|
|
LumberyardToolUpdateMaterialTreeView;
|
|
textField -edit -text `LumberyardToolGetMaterialExportPath` LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD;
|
|
LumberyardToolEnsureAllCorrectMaterialGroupCustomExportPath;
|
|
LumberyardToolUpdateMaterialAdvancedOptionsFrame;
|
|
}
|
|
|
|
//! Update the material advance option frame.
|
|
global proc LumberyardToolUpdateMaterialAdvancedOptionsFrame()
|
|
{
|
|
global int $g_currentSelectedMaterialGroupId;
|
|
|
|
if ($g_currentSelectedMaterialGroupId != -1)
|
|
{
|
|
// Display the custom export path of the selected material group item.
|
|
string $customFilePath = `LumberyardToolGetSelectedMaterialGroupCustomExportPath`;
|
|
textField -edit -enable true -text $customFilePath LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD;
|
|
iconTextButton -edit -enable true LUMBERYARDTOOL_MATERIALCUSTOMPATH_BUTTON;
|
|
string $selectedGroup = `LumberyardToolGetMaterialGroupItemNameValue $g_currentSelectedMaterialGroupId`;
|
|
connectControl LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD ($selectedGroup + ".customExportPath");
|
|
}
|
|
else
|
|
{
|
|
textField -edit -enable false -text "" LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD;
|
|
iconTextButton -edit -enable false LUMBERYARDTOOL_MATERIALCUSTOMPATH_BUTTON;
|
|
}
|
|
}
|
|
|
|
//! Resize Lumberyard Tool window by collapsing or expanding the material frame.
|
|
/*!
|
|
\param $collapse Whether collapse or expand the material frame.
|
|
*/
|
|
global proc LumberyardMaterialResizeWindow(int $collapse)
|
|
{
|
|
global int $g_materialHeightDiff;
|
|
global int $g_materialAdvanceOptionHeightDiff;
|
|
int $materialHeightDiff = $g_materialHeightDiff;
|
|
if (`frameLayout -query -collapse LUMBERYARDTOOL_MATERIALADVANCEDOPTIONS_FRAME`)
|
|
{
|
|
$materialHeightDiff = $g_materialHeightDiff - $g_materialAdvanceOptionHeightDiff;
|
|
}
|
|
if ($collapse)
|
|
{
|
|
$materialHeightDiff = -$materialHeightDiff;
|
|
}
|
|
LumberyardToolResizeWindow $materialHeightDiff;
|
|
}
|
|
|
|
//! Collapse material advance option frame.
|
|
global proc LumberyardMaterialCollapseAdvanceOptionsFrame()
|
|
{
|
|
global int $g_materialAdvanceOptionHeightDiff;
|
|
if (!`frameLayout -query -collapse LUMBERYARDTOOL_MATERIALADVANCEDOPTIONS_FRAME`)
|
|
{
|
|
frameLayout -edit -collapse true LUMBERYARDTOOL_MATERIALADVANCEDOPTIONS_FRAME;
|
|
LumberyardToolResizeWindow (-$g_materialAdvanceOptionHeightDiff);
|
|
}
|
|
}
|
|
|
|
// The add material button.
|
|
global string $g_addMaterialButton;
|
|
|
|
//! Create material export main frame.
|
|
global proc LumberyardToolCreateMaterialFrame()
|
|
{
|
|
global string $g_addMaterialButton;
|
|
global int $g_boxWidth;
|
|
global int $g_buttonSpace;
|
|
global float $g_UIColor[];
|
|
int $buttonWidth = ($g_boxWidth - $g_buttonSpace * 2) / 3;
|
|
global int $g_materialHeightDiff;
|
|
global int $g_materialAdvanceOptionHeightDiff;
|
|
|
|
setParent LUMBERYARDTOOL_MAIN_LAYOUT;
|
|
frameLayout -collapsable true -marginHeight 5 -marginWidth 5 -label "Material Export"
|
|
-collapseCommand ("LumberyardMaterialResizeWindow " + 1) -expandCommand ("LumberyardMaterialResizeWindow " + 0)
|
|
LUMBERYARDTOOL_MATERIAL_FRAME;
|
|
{
|
|
columnLayout -adjustableColumn true LUMBERYARDTOOL_MATERIAL_LAYOUT;
|
|
{
|
|
scrollLayout -height 200 -backgroundColor 0 0 0 -visible true LUMBERYARDTOOL_MATERIAL_TREEVIEW;
|
|
|
|
setParent ..;
|
|
rowColumnLayout -numberOfRows 1 -width $g_boxWidth -columnSpacing 2 $g_buttonSpace;
|
|
button -label "Hypershade" -width $buttonWidth -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-command ("LumberyardToolOpenSelectedInHyperShade");
|
|
button -label "Add Group" -width $buttonWidth -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-command ("LumberyardToolAddNewMaterialGroup");
|
|
$g_addMaterialButton = `button -label "Add Material" -width $buttonWidth -enable false
|
|
-backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2] -command ("LumberyardAddNewMaterialToGroup")`;
|
|
|
|
setParent ..;
|
|
rowColumnLayout -numberOfRows 1 -height 30 -rowOffset 1 "both" 4 -columnSpacing 3 $g_buttonSpace;
|
|
text -label "Export Path" -width 70;
|
|
textField -text `LumberyardToolGetMaterialExportPath` -width 200 -changeCommand ("LumberyardToolUpdateMaterialExportPath")
|
|
LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD;
|
|
popupMenu;
|
|
{
|
|
menuItem -label "Reset" -command ("LumberyardResetCustomString LUMBERYARDTOOL_MATERIALEXPORTPATH_TEXTFIELD");
|
|
}
|
|
iconTextButton -image "icons/lumberyard_folder_icon.png" -width 20 -height 18 -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-command ("LumberyardToolSetMaterialExportPathFromFileBrowser");
|
|
|
|
// Create Advanced Options frame
|
|
setParent LUMBERYARDTOOL_MATERIAL_LAYOUT;
|
|
frameLayout -collapsable true -collapse false -marginHeight 5 -marginWidth 5 -label "Advanced Options"
|
|
-collapseCommand ("LumberyardToolResizeWindow " + (-$g_materialAdvanceOptionHeightDiff)) -expandCommand ("LumberyardToolResizeWindow " + $g_materialAdvanceOptionHeightDiff)
|
|
LUMBERYARDTOOL_MATERIALADVANCEDOPTIONS_FRAME;
|
|
rowColumnLayout -numberOfRows 1 -height 30 -rowOffset 1 "both" 4 -columnSpacing 3 $g_buttonSpace;
|
|
text -label "Custom Path" -width 70;
|
|
textField -width 190 -text `LumberyardToolGetSelectedMaterialGroupCustomExportPath`
|
|
-changeCommand ("LumberyardToolSetMaterialGroupCustomExportPathFromTextField")
|
|
LUMBERYARDTOOL_MATERIALCUSTOMPATH_TEXTFIELD;
|
|
iconTextButton -image "icons/lumberyard_folder_icon.png" -width 20 -height 18 -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-command ("LumberyardToolSetMaterialGroupCustomExportPathFromBrowser")
|
|
LUMBERYARDTOOL_MATERIALCUSTOMPATH_BUTTON;
|
|
LumberyardToolUpdateMaterialAdvancedOptionsFrame;
|
|
|
|
setParent LUMBERYARDTOOL_MATERIAL_LAYOUT;
|
|
button -label "Export Materials" -backgroundColor $g_UIColor[0] $g_UIColor[1] $g_UIColor[2]
|
|
-command ("LumberyardToolExportCheckedMaterialGroups 1") LUMBERYARDTOOL_EXPORTMATERIAL_BUTTON;
|
|
}
|
|
}
|
|
|
|
LumberyardMaterialOnLoad;
|
|
|
|
scriptJob -event "NewSceneOpened" "LumberyardMaterialOnLoad" -parent "LUMBERYARDTOOL_MAIN_LAYOUT";
|
|
scriptJob -event "PostSceneRead" "LumberyardMaterialOnLoad" -parent "LUMBERYARDTOOL_MAIN_LAYOUT";
|
|
scriptJob -event "NameChanged" "LumberyardToolUpdateMaterialTreeView" -parent "LUMBERYARDTOOL_MAIN_LAYOUT";
|
|
}
|