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.
658 lines
23 KiB
Plaintext
658 lines
23 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.
|
|
*
|
|
*/
|
|
|
|
// List of the current animLayers known to the Utilities, this is
|
|
// used to determine operations performed in the Maya main workflow and
|
|
// keep the data backend synchronized with it.
|
|
global string $g_animLayers[];
|
|
|
|
//! Forces a refresh of the Lumberyard Animation Manager and Lumberyard Animation Pane.
|
|
global proc LumberyardUtilitiesUpdateAnimationUI()
|
|
{
|
|
if(`window -exists LUMBERYARDANIMATIONMANAGER_WINDOW`)
|
|
{
|
|
LumberyardAnimationManagerReadExports();
|
|
}
|
|
|
|
if(`window -exists LUMBERYARDTOOL_MAIN_WINDOW`)
|
|
{
|
|
LumberyardAnimationPaneReadExports();
|
|
}
|
|
}
|
|
|
|
//! Generates a unique animation export name based on a requested name.
|
|
/*!
|
|
\param $requestedName The desired name that may be changed to guarantee uniqueness.
|
|
*/
|
|
global proc string LumberyardUtilitiesGetUniqueAnimationName(string $requestedName)
|
|
{
|
|
if ($requestedName == "")
|
|
{
|
|
$requestedName = "animationExport";
|
|
}
|
|
return `LumberyardUtilitiesVerifyAnimationRequestName $requestedName ""`;
|
|
}
|
|
|
|
//! Verify if requested name is valid and return a proper name for the animation.
|
|
/*
|
|
\param $requestedName The desired name of the animation.
|
|
\param $currentName The current name of the animation.
|
|
*/
|
|
global proc string LumberyardUtilitiesVerifyAnimationRequestName(string $requestedName, string $currentName)
|
|
{
|
|
return `LumberyardVerifySceneObjectRequestNameWithPrefix $requestedName $currentName "LUMBERYARD_ANIMATIONEXPORT_GROUP|"`;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// For manipulating layer data
|
|
|
|
//! Returns the list of animLayers defined by Maya.
|
|
/*!
|
|
\note
|
|
This will return the identical ordering to Maya, but only if displaying
|
|
them newest animLayer first, which is the default view. It will not
|
|
guarantee identical ordering for other Maya animLayer displays.
|
|
*/
|
|
global proc string[] LumberyardUtilitiesGetAnimLayers()
|
|
{
|
|
string $layers[];
|
|
if(`animLayer -query -exists "BaseAnimation"`)
|
|
{
|
|
$layers = `animLayer -query -children "BaseAnimation"`;
|
|
|
|
$layers = `LumberyardUtilitiesReverseStringArray $layers`;
|
|
}
|
|
$layers[size($layers)] = "BaseAnimation";
|
|
return $layers;
|
|
}
|
|
|
|
//! This removes the specified animLayers from the active list for all animation exports.
|
|
/*!
|
|
\param $removeLayers The name of all animLayers that should be removed.
|
|
*/
|
|
proc LumberyardUtilitiesRemoveAnimLayers(string $removeLayers[])
|
|
{
|
|
if(`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
string $exportNodes[] = `listRelatives -children "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
for($exportNode in $exportNodes)
|
|
{
|
|
string $exportLayers[] = `LumberyardUtilitiesGetAnimationExportLayers $exportNode`;
|
|
$exportLayers = `stringArrayRemove $removeLayers $exportLayers`;
|
|
LumberyardUtilitiesSetAnimationExportLayers($exportNode, $exportLayers);
|
|
LumberyardUtilitiesUpdateAnimationUI();
|
|
}
|
|
}
|
|
}
|
|
|
|
//! This will update an old animLayer name to a new name for all animation exports' active animLayer list.
|
|
/*!
|
|
\param $oldName The name of the animLayer to replace.
|
|
\param $newName The name that should be stored in its place.
|
|
*/
|
|
proc LumberyardUtilitiesRenameAnimLayer(string $oldName, string $newName)
|
|
{
|
|
if(`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
string $exportNodes[] = `listRelatives -children "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
for($exportNode in $exportNodes)
|
|
{
|
|
string $exportLayers[] = `LumberyardUtilitiesGetAnimationExportLayers $exportNode`;
|
|
int $index = `stringArrayFind $oldName 0 $exportLayers`;
|
|
if($index >= 0)
|
|
{
|
|
$exportLayers[$index] = $newName;
|
|
}
|
|
LumberyardUtilitiesSetAnimationExportLayers($exportNode, $exportLayers);
|
|
LumberyardUtilitiesUpdateAnimationUI();
|
|
}
|
|
}
|
|
}
|
|
|
|
//! Callback which queries Maya animLayer state, and synchronizes the data backend with the current state.
|
|
/*!
|
|
\note
|
|
This should be called whenever an animLayer is added, removed, renamed or deleted in Maya. If animLayer is
|
|
manipulated by scripts, this should be called after any operations of these types.
|
|
*/
|
|
global proc LumberyardUtilitiesUpdateAnimationLayers()
|
|
{
|
|
global string $g_animLayers[];
|
|
string $layers[];
|
|
$layers = `ls -type "animLayer"`;
|
|
|
|
if(size($g_animLayers) == size($layers))
|
|
{
|
|
// A layer was renamed
|
|
string $oldNames[];
|
|
string $newName;
|
|
|
|
for($animLayer in $g_animLayers)
|
|
{
|
|
if(!`stringArrayContains $animLayer $layers`)
|
|
{
|
|
$oldNames[size($oldNames)] = $animLayer;
|
|
}
|
|
}
|
|
|
|
if(size($oldNames) > 1)
|
|
{
|
|
print("Warning: Received multiple rename requests in a single operation, removing nodes instead\n");
|
|
LumberyardUtilitiesRemoveAnimLayers($oldNames);
|
|
$g_animLayers = $layers;
|
|
return;
|
|
}
|
|
if(size($oldNames) == 0)
|
|
{
|
|
// No renamed asset found
|
|
return;
|
|
}
|
|
|
|
for($animLayer in $layers)
|
|
{
|
|
if(!`stringArrayContains $animLayer $g_animLayers`)
|
|
{
|
|
$newName = $animLayer;
|
|
}
|
|
}
|
|
|
|
LumberyardUtilitiesRenameAnimLayer($oldNames[0], $newName);
|
|
}
|
|
else if(size($g_animLayers) > size($layers))
|
|
{
|
|
// One or more layers were deleted
|
|
if(`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
string $deletedLayers[];
|
|
for($animLayer in $g_animLayers)
|
|
{
|
|
if(!`stringArrayContains $animLayer $layers`)
|
|
{
|
|
// Deleted Layer
|
|
$deletedLayers[size($deletedLayers)] = $animLayer;
|
|
}
|
|
}
|
|
|
|
string $exportNodes[] = `listRelatives -children "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
for($exportNode in $exportNodes)
|
|
{
|
|
LumberyardUtilitiesRemoveAnimLayers($deletedLayers);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Store layer list for next AnimLayer operation
|
|
$g_animLayers = $layers;
|
|
}
|
|
|
|
//! Utility function to create a command that will generate correct export behavior based on animLayer settings.
|
|
/*!
|
|
\param $exportLayerString The string attribute encoding animLayer selections for an animation export.
|
|
\note The default behavior is to mute any layers not contained in the exportLayer selections during export.
|
|
*/
|
|
proc string LumberyardUtilitiesConvertAnimLayerStringToCommand(string $exportLayerString)
|
|
{
|
|
string $exportLayers[] = `stringToStringArray $exportLayerString ","`;
|
|
string $validLayers[] = `LumberyardUtilitiesGetAnimLayers`;
|
|
string $command = "";
|
|
|
|
for($i = 0; $i < size($validLayers); $i++)
|
|
{
|
|
if($validLayers[$i] != "BaseAnimation")
|
|
{
|
|
int $value = !`stringArrayContains $validLayers[$i] $exportLayers`;
|
|
$command = $command + "setAttr " + $validLayers[$i] + ".mute " + $value + ";";
|
|
}
|
|
}
|
|
|
|
|
|
return $command;
|
|
}
|
|
|
|
//! Upgrades the old Crytek format for animLayer commands into the new Lumberyard format.
|
|
/*!
|
|
\param $animLayerCommand The animLayer command for an animation export encoded in Crytek format.
|
|
*/
|
|
proc string[] LumberyardUtilitiesUpgradeAnimLayerCommand(string $animLayerCommand)
|
|
{
|
|
string $animLayers[];
|
|
string $commands[];
|
|
int $numCommands = `tokenize $animLayerCommand ";" $commands`;
|
|
|
|
string $elements[];
|
|
|
|
for($i = 0; $i < $numCommands; $i = $i + 2)
|
|
{
|
|
tokenize $commands[$i] " " $elements;
|
|
// Validate for proper command formatting.
|
|
if(size($elements) == 3)
|
|
{
|
|
int $value = (int)$elements[2];
|
|
if($value != 0)
|
|
{
|
|
tokenize $elements[1] "." $elements;
|
|
if(size($elements) == 2)
|
|
{
|
|
$animLayers[size($animLayers)] = $elements[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $animLayers;
|
|
}
|
|
|
|
//! Upgrades old Crytek into properly formatted Lumberyard animation export data.
|
|
/*!
|
|
\note
|
|
The old Crytek format used a single monolithic string that was constantly built and tokenized to store this data.
|
|
The data was moved into a node attributes to make it less computationally expensive, as well as easier to read and
|
|
manipulate. Note that this is a destructive operation, the old Crytek data is removed to prevent detecting old data
|
|
every time the file is opened.
|
|
\todo
|
|
We may consider backing up the Crytek data in a separate location so it can be restored if it is requested by customers,
|
|
but we would prefer to only forward port data in the long term.
|
|
*/
|
|
global proc int LumberyardUtilitiesUpgradeAnimationData()
|
|
{
|
|
string $exportStringsRaw[] = `cryAnimGetRanges`;
|
|
|
|
if(size($exportStringsRaw) >= 1 && $exportStringsRaw[0] != "")
|
|
{
|
|
string $upgradeChoice = `confirmDialog -title "Upgrade"
|
|
-message "Detected old animation data. Do you wish to upgrade it to the new tool format? (This operation will remove the old data)"
|
|
-button "Yes" -button "No" -defaultButton "Yes" -cancelButton "No" -dismissString "No"`;
|
|
|
|
if($upgradeChoice == "Yes")
|
|
{
|
|
string $exportStringsRaw[] = `cryAnimGetRanges`;
|
|
cryAnimRemoveAllAnimRanges();
|
|
for($exportStringRaw in $exportStringsRaw)
|
|
{
|
|
string $exportParameters[] = `python("mau.AMZN_DecodeAnimRangeString(\"" + $exportStringRaw + "\")")`;
|
|
|
|
string $exportLayers[];
|
|
if(size($exportParameters) >= 6)
|
|
{
|
|
$exportLayers = `LumberyardUtilitiesUpgradeAnimLayerCommand $exportParameters[5]`;
|
|
}
|
|
|
|
LumberyardUtilitiesCreateAnimationExport($exportParameters[0], $exportParameters[1], $exportParameters[2],
|
|
$exportParameters[3], $exportParameters[4], $exportLayers);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//! Creates the node to contain animation export data, and store requested values in the node
|
|
/*!
|
|
\param $startFrame The first frame to export for the animation
|
|
\param $endFrame The last frame to export for the animation
|
|
\param $exportName The name of the i_caf file to generate when exporting the animation
|
|
\param $rootJoint The root joint to use when exporting the animation. Only joints below the root will be exported.
|
|
\param $exportPath The absolute path to store the i_caf when exporting the animation.
|
|
\param $exportLayers A list of the layers that should be active (not muted) when exporting the animation.
|
|
*/
|
|
global proc LumberyardUtilitiesCreateAnimationExport(int $startFrame, int $endFrame, string $exportName, string $rootJoint,
|
|
string $exportPath, string $exportLayers[])
|
|
{
|
|
if(!`objExists "LUMBERYARD_EXPORT_GROUP"`)
|
|
{
|
|
group -world -empty -name "LUMBERYARD_EXPORT_GROUP";
|
|
}
|
|
|
|
|
|
if(!`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
group -empty -parent "LUMBERYARD_EXPORT_GROUP" -name "LUMBERYARD_ANIMATIONEXPORT_GROUP";
|
|
}
|
|
else
|
|
{
|
|
string $parents[] = `listRelatives -parent "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
if (!stringArrayContains("LUMBERYARD_EXPORT_GROUP", $parents))
|
|
{
|
|
parent ("LUMBERYARD_ANIMATIONEXPORT_GROUP", "LUMBERYARD_EXPORT_GROUP");
|
|
}
|
|
}
|
|
|
|
string $newExportNode = `createNode "transform" -name AnimationExport -parent "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
addAttr -longName "shouldExport" -attributeType bool $newExportNode;
|
|
setAttr ($newExportNode+".shouldExport") 1;
|
|
LumberyardUtilitiesSetAnimationStartFrame($newExportNode, $startFrame);
|
|
LumberyardUtilitiesSetAnimationEndFrame($newExportNode, $endFrame);
|
|
LumberyardUtilitiesSetAnimationExportName($newExportNode, $exportName);
|
|
LumberyardUtilitiesSetAnimationRootJoint($newExportNode, $rootJoint);
|
|
LumberyardUtilitiesSetAnimationExportPath($newExportNode, $exportPath);
|
|
LumberyardUtilitiesSetAnimationExportLayers($newExportNode, $exportLayers);
|
|
}
|
|
|
|
//! Deletes an animation export and its data
|
|
/*!
|
|
\param $exportNode The name of the animation export node to delete
|
|
*/
|
|
global proc LumberyardUtilitiesDeleteAnimationExport(string $exportNode)
|
|
{
|
|
if(!`objExists ("LUMBERYARD_ANIMATIONEXPORT_GROUP|" + $exportNode)`)
|
|
{
|
|
return;
|
|
}
|
|
|
|
delete ("LUMBERYARD_ANIMATIONEXPORT_GROUP|" + $exportNode);
|
|
LumberyardUtilitiesUpdateAnimationUI();
|
|
}
|
|
|
|
//! Returns a list of all animation exports in the scene
|
|
global proc string[] LumberyardUtilitiesGetAnimationExportNodes()
|
|
{
|
|
string $exportNodes[];
|
|
|
|
if(`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
$exportNodes = `listRelatives -children "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
}
|
|
|
|
return $exportNodes;
|
|
}
|
|
|
|
//! Returns true if the animation export node exists, and has all required attributes
|
|
/*!
|
|
\param $exportNode The name of the animation export node to validate
|
|
*/
|
|
global proc int LumberyardUtilitiesAnimationExportIsValid(string $exportNode)
|
|
{
|
|
string $fullname = "LUMBERYARD_ANIMATIONEXPORT_GROUP|"+$exportNode;
|
|
if (!`objExists $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!`attributeExists "startFrame" $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!`attributeExists "endFrame" $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!`attributeExists "exportName" $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!`attributeExists "rootJoint" $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(!`attributeExists "exportPath" $fullname`)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
//! Sets an integer attribute on an animation export node, creating it if needed
|
|
/*!
|
|
\param $exportNode The node to set the attribute on
|
|
\param $attribute The name of the attribute to set
|
|
\param $value The value to store in the attribute
|
|
*/
|
|
proc LumberyardUtilitiesSetAnimationIntAttr(string $exportNode, string $attribute, int $value)
|
|
{
|
|
if(!`attributeExists $attribute $exportNode`)
|
|
{
|
|
addAttr -longName $attribute -attributeType long $exportNode;
|
|
}
|
|
|
|
setAttr ("LUMBERYARD_ANIMATIONEXPORT_GROUP|" + $exportNode + "." + $attribute) $value;
|
|
}
|
|
|
|
//! Sets a string attribute on an animation export node, creating it if needed
|
|
/*!
|
|
\param $exportNode The node to set the attribute on
|
|
\param $attribute The name of the attribute to set
|
|
\param $value The value to store in the attribute
|
|
*/
|
|
proc LumberyardUtilitiesSetAnimationStringAttr(string $exportNode, string $attribute, string $value)
|
|
{
|
|
if(!`attributeExists $attribute $exportNode`)
|
|
{
|
|
addAttr -longName $attribute -dataType "string" $exportNode;
|
|
}
|
|
|
|
setAttr -type "string" ("LUMBERYARD_ANIMATIONEXPORT_GROUP|" + $exportNode + "." + $attribute) $value;
|
|
}
|
|
|
|
//! Gets the value of an animation export node attribute if it exists. If not, returns a default value.
|
|
/*!
|
|
\param $exportNode The animation export node to fetch the value for.
|
|
\param $attribute The name of the attribute to query.
|
|
\param $defaultValue The default value that will be returned if the attribute or node are not found.
|
|
\note
|
|
This always returns a string. The caller is responsible to cast the return value to the appropriate type.
|
|
*/
|
|
proc string LumberyardUtilitiesGetAnimationAttr(string $exportNode, string $attribute, string $defaultValue)
|
|
{
|
|
string $return = $defaultValue;
|
|
|
|
if(`LumberyardUtilitiesAnimationExportIsValid $exportNode`)
|
|
{
|
|
$return = `getAttr ("LUMBERYARD_ANIMATIONEXPORT_GROUP|" + $exportNode + "." + $attribute) $exportNode`;
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
//! Sets the start frame value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the start frame for
|
|
\param $startFrame The first frame for the animation export.
|
|
*/
|
|
global proc LumberyardUtilitiesSetAnimationStartFrame(string $exportNode, int $startFrame)
|
|
{
|
|
LumberyardUtilitiesSetAnimationIntAttr($exportNode, "startFrame", $startFrame);
|
|
|
|
}
|
|
|
|
//! Gets the start frame value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the start frame for
|
|
*/
|
|
global proc int LumberyardUtilitiesGetStartFrame(string $exportNode)
|
|
{
|
|
string $value = `LumberyardUtilitiesGetAnimationAttr $exportNode "startFrame" "-1"`;
|
|
int $intValue = (int)$value;
|
|
return $intValue;
|
|
}
|
|
|
|
//! Sets the end frame value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the end frame for
|
|
\param $endFrame The last frame for the animation export.
|
|
*/
|
|
global proc LumberyardUtilitiesSetAnimationEndFrame(string $exportNode, int $endFrame)
|
|
{
|
|
LumberyardUtilitiesSetAnimationIntAttr($exportNode, "endFrame", $endFrame);
|
|
}
|
|
|
|
//! Gets the end frame value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the end frame for
|
|
*/
|
|
global proc int LumberyardUtilitiesGetAnimationEndFrame(string $exportNode)
|
|
{
|
|
string $value = `LumberyardUtilitiesGetAnimationAttr $exportNode "endFrame" "-1"`;
|
|
int $intValue = (int)$value;
|
|
return $intValue;
|
|
}
|
|
|
|
//! Sets the export name value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the export name for
|
|
\param $exportName The name of the i_caf to create for the animation export.
|
|
*/
|
|
global proc string LumberyardUtilitiesSetAnimationExportName(string $exportNode, string $exportName)
|
|
{
|
|
LumberyardUtilitiesSetAnimationStringAttr($exportNode, "exportName", $exportName);
|
|
if(`window -exists LUMBERYARDTOOL_MAIN_WINDOW`)
|
|
{
|
|
LumberyardAnimationPaneReadExports();
|
|
}
|
|
return $exportName;
|
|
}
|
|
|
|
//! Gets the export name value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the export name for
|
|
*/
|
|
global proc string LumberyardUtilitiesGetAnimationExportName(string $exportNode)
|
|
{
|
|
return `LumberyardUtilitiesGetAnimationAttr $exportNode "exportName" ""`;
|
|
}
|
|
|
|
//! Sets the root joint value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the root joint for
|
|
\param $rootJoint The root joint for the animation export. Only joints below this will be exported.
|
|
*/
|
|
global proc LumberyardUtilitiesSetAnimationRootJoint(string $exportNode, string $rootJoint)
|
|
{
|
|
LumberyardUtilitiesSetAnimationStringAttr($exportNode, "rootJoint", $rootJoint);
|
|
}
|
|
|
|
//! Gets the root joint value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the root joint for
|
|
*/
|
|
global proc string LumberyardUtilitiesGetAnimationRootJoint(string $exportNode)
|
|
{
|
|
return `LumberyardUtilitiesGetAnimationAttr $exportNode "rootJoint" ""`;
|
|
}
|
|
|
|
//! Sets the export layers used for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the export layers for.
|
|
\param $exportLayers A list containing all animLayers that should be active when exporting the animation export.
|
|
*/
|
|
global proc LumberyardUtilitiesSetAnimationExportLayers(string $exportNode, string $exportLayers[])
|
|
{
|
|
string $exportLayerString = `stringArrayToString $exportLayers ","`;
|
|
LumberyardUtilitiesSetAnimationStringAttr($exportNode, "exportLayers", $exportLayerString);
|
|
}
|
|
|
|
//! Gets a list of the export layers used for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the export layers for.
|
|
*/
|
|
global proc string[] LumberyardUtilitiesGetAnimationExportLayers(string $exportNode)
|
|
{
|
|
string $animLayerString = `LumberyardUtilitiesGetAnimationAttr $exportNode "exportLayers" ""`;
|
|
string $animLayers[] = `stringToStringArray $animLayerString ","`;
|
|
|
|
if(!`stringArrayContains "BaseAnimation" $animLayers`)
|
|
{
|
|
$animLayers[size($animLayers)] = "BaseAnimation";
|
|
}
|
|
|
|
return $animLayers;
|
|
}
|
|
|
|
//! Sets the export path value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to set the export path for
|
|
\param $exportPath The absolute export path used when generating the i_caf for the animation export.
|
|
*/
|
|
global proc string LumberyardUtilitiesSetAnimationExportPath(string $exportNode, string $exportPath)
|
|
{
|
|
$exportPath = `cryExportFixupPath $exportPath`;
|
|
LumberyardUtilitiesSetAnimationStringAttr($exportNode, "exportPath", $exportPath);
|
|
return $exportPath;
|
|
}
|
|
|
|
//! Gets the export path value for an animation export
|
|
/*!
|
|
\param $exportNode The name of the animation export node to get the export path for
|
|
*/
|
|
global proc string LumberyardUtilitiesGetAnimationExportPath(string $exportNode)
|
|
{
|
|
return `LumberyardUtilitiesGetAnimationAttr $exportNode "exportPath" ""`;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Functions tied to buttons
|
|
|
|
//! Sets the start and end frame for an animation export to match the Maya timeline
|
|
/*!
|
|
\param $exportName The name of the animation export node to snap to the Maya timeline.
|
|
*/
|
|
global proc LumberyardUtilitiesSnapAnimationToTimeline(string $exportNode)
|
|
{
|
|
if(!`LumberyardUtilitiesAnimationExportIsValid $exportNode`)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int $startFrame = `playbackOptions -query -minTime`;
|
|
int $endFrame = `playbackOptions -query -maxTime`;
|
|
setAttr ($exportNode+".startFrame") $startFrame;
|
|
setAttr ($exportNode+".endFrame") $endFrame;
|
|
|
|
if(`window -exists LUMBERYARDANIMATIONMANAGER_WINDOW`)
|
|
{
|
|
LumberyardAnimationManagerReadExports();
|
|
}
|
|
}
|
|
|
|
//! Exports all animation exports that have the shouldExport attribute set to true.
|
|
/*!
|
|
\param $blockOnWarnings If not zero/false, this will keep Export Progress UI from blocking for user input for warnings.
|
|
\note
|
|
$blockOnWarnings is only intended for use for batch operations at this time.
|
|
*/
|
|
global proc LumberyardUtilitiesExportSelectedAnimations(int $blockOnWarnings)
|
|
{
|
|
if(!`objExists "LUMBERYARD_ANIMATIONEXPORT_GROUP"`)
|
|
{
|
|
return;
|
|
}
|
|
|
|
string $children[] = `listRelatives -children "LUMBERYARD_ANIMATIONEXPORT_GROUP"`;
|
|
|
|
for($child in $children)
|
|
{
|
|
if(`LumberyardUtilitiesAnimationExportIsValid $child`)
|
|
{
|
|
string $fullname = "LUMBERYARD_ANIMATIONEXPORT_GROUP|"+$child;
|
|
int $shouldExport = `getAttr ($fullname+".shouldExport")`;
|
|
if($shouldExport != 0)
|
|
{
|
|
string $startFrame = `getAttr ($fullname+".startFrame")`;
|
|
string $endFrame = `getAttr ($fullname+".endFrame")`;
|
|
string $exportName = `getAttr ($fullname+".exportName")`;
|
|
string $rootJoint = `getAttr ($fullname+".rootJoint")`;
|
|
string $exportPath = `getAttr ($fullname+".exportPath")`;
|
|
string $exportLayers = `getAttr ($fullname+".exportLayers")`;
|
|
string $layerCommand = `LumberyardUtilitiesConvertAnimLayerStringToCommand $exportLayers`;
|
|
cryIssueAnimationExportCommand($startFrame, $endFrame, $exportName, $rootJoint, $exportPath, $layerCommand, $blockOnWarnings, LumberyardExportGetAdditionalExportOptions());
|
|
}
|
|
}
|
|
}
|
|
} |