mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
3442aceb0f
This streamlines much of the code and makes it easier to find and follow how different asset, object and file types are handled by the asset browser Also clears out various bits of cruft and old commented blocks of code
2842 lines
85 KiB
Plaintext
2842 lines
85 KiB
Plaintext
//AssetBrowser.addToolbarButton
|
|
function AssetBrowser::addToolbarButton(%this)
|
|
{
|
|
%button = new GuiBitmapButtonCtrl() {
|
|
canSaveDynamicFields = "0";
|
|
internalName = AssetBrowserBtn;
|
|
Enabled = "1";
|
|
isContainer = "0";
|
|
Profile = "ToolsGuiButtonProfile";
|
|
HorizSizing = "right";
|
|
VertSizing = "bottom";
|
|
position = "180 0";
|
|
Extent = "25 19";
|
|
MinExtent = "8 2";
|
|
canSave = "1";
|
|
Visible = "1";
|
|
Command = "AssetBrowser.ShowDialog();";
|
|
tooltipprofile = "ToolsGuiToolTipProfile";
|
|
ToolTip = "Asset Browser";
|
|
hovertime = "750";
|
|
bitmapAsset = "ToolsModule:assetBrowser_n_image";
|
|
bitmapMode = "Stretched";
|
|
buttonType = "ToggleButton";
|
|
groupNum = "0";
|
|
useMouseEvents = "0";
|
|
};
|
|
ToolsToolbarArray.add(%button);
|
|
EWToolsToolbar.setExtent((29 + 4) * (ToolsToolbarArray.getCount()) + 4 SPC "32");
|
|
}
|
|
//
|
|
|
|
//
|
|
function AssetBrowser::registerAssetType(%assetTypeName, %humanReadableName, %assetClassNamesList, %showInFilters)
|
|
{
|
|
if(%showInFilters $= "")
|
|
%showInFilters = true;
|
|
|
|
ABAssetTypesList.add("Asset", %assetTypeName TAB %humanReadableName TAB %assetClassNamesList TAB %showInFilters);
|
|
}
|
|
|
|
function AssetBrowser::registerFileType(%fileTypeName, %humanReadableName, %fileExtensionsList, %showInFilters)
|
|
{
|
|
if(%showInFilters $= "")
|
|
%showInFilters = true;
|
|
|
|
ABAssetTypesList.add("File", %fileTypeName TAB %humanReadableName TAB %fileExtensionsList TAB %showInFilters);
|
|
}
|
|
|
|
function AssetBrowser::registerObjectType(%objectTypeName, %humanReadableName, %objectClassNames, %showInFilters)
|
|
{
|
|
if(%showInFilters $= "")
|
|
%showInFilters = true;
|
|
|
|
ABAssetTypesList.add("Object", %objectTypeName TAB %humanReadableName TAB %objectClassNames TAB %showInFilters);
|
|
}
|
|
|
|
function AssetBrowser::callAssetTypeFunc(%this, %type, %function, %param0, %param1, %param2, %param3, %param4)
|
|
{
|
|
//echo("AssetBrowser::callAssetTypeFunc() - deets: " @ %type @ ", " @ %function @ ", " @ %param0 @ ", " @ %param1 @ ", " @ %param2 @ ", " @ %param3 @ ", " @ %param4);
|
|
$paramCache0 = %param0;
|
|
$paramCache1 = %param1;
|
|
$paramCache2 = %param2;
|
|
$paramCache3 = %param3;
|
|
$paramCache4 = %param4;
|
|
|
|
$CurrentAssetBrowser = %this;
|
|
|
|
//look up the type group
|
|
%typeGroup = "";
|
|
%typeData = "";
|
|
for(%i=0; %i < ABAssetTypesList.count(); %i++)
|
|
{
|
|
%group = ABAssetTypesList.getKey(%i);
|
|
%typeData = ABAssetTypesList.getValue(%i);
|
|
|
|
if(getField(%typeData, 0) $= %type)
|
|
{
|
|
%typeGroup = %group;
|
|
%typeData = %typeData;
|
|
break;
|
|
}
|
|
}
|
|
|
|
%paramOffset = 0;
|
|
%isStaticCall = false;
|
|
%command = "";
|
|
if(%typeGroup $= "Asset")
|
|
{
|
|
//check to see if the first param is an asset definition
|
|
if(isObject(%param0) && %param0.isInNamespaceHierarchy("AssetBase"))
|
|
{
|
|
if(%param0.isMethod(%function))
|
|
{
|
|
%command = %param0 @ "." @ %function @ "(";
|
|
%paramOffset = 1;
|
|
}
|
|
else
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(" @ %param0;
|
|
%paramOffset = 1;
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(AssetDatabase.isDeclaredAsset(%param0))
|
|
{
|
|
%assetDef = AssetDatabase.acquireAsset(%param0);
|
|
if(%assetDef.isMethod(%function))
|
|
{
|
|
%command = %assetDef @ "." @ %function @ "(";
|
|
%paramOffset = 1;
|
|
}
|
|
else
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(" @ %assetDef;
|
|
%paramOffset = 1;
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//we may have to build the assetID
|
|
%assetId = %param0 @ ":" @ %param1;
|
|
if(AssetDatabase.isDeclaredAsset(%assetId))
|
|
{
|
|
%assetDef = AssetDatabase.acquireAsset(%assetId);
|
|
|
|
if(%assetDef.isMethod(%function))
|
|
{
|
|
%command = %assetDef @ "." @ %function @ "(";
|
|
%paramOffset = 2;
|
|
}
|
|
else
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(" @ %assetDef;
|
|
%paramOffset = 2;
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(%typeGroup $= "File")
|
|
{
|
|
%compoundPath = %param0 @ "/" @ %param1;
|
|
if(isFile(%compoundPath) || isDirectory(%compoundPath))
|
|
{
|
|
if(isMethod(%type, %function))
|
|
{
|
|
%command = %type @ "::" @ %function @ "(\"" @ %compoundPath @ "\"";
|
|
%paramOffset = 2;
|
|
%isStaticCall = true;
|
|
}
|
|
else
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(\"" @ %compoundPath @ "\"";
|
|
%paramOffset = 2;
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
else if(isFile(%param0) || isDirectory(%param0))
|
|
{
|
|
if(isMethod(%type, %function))
|
|
{
|
|
%command = %type @ "::" @ %function @ "(\"" @ %param0 @ "\"";
|
|
%paramOffset = 1;
|
|
%isStaticCall = true;
|
|
}
|
|
else
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(\"" @ %param0 @ "\"";
|
|
%paramOffset = 1;
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
}
|
|
else if(%typeGroup $= "Object")
|
|
{
|
|
if(isObject(%param0) && %param0.isMethod(%function))
|
|
{
|
|
%command = %param0 @ "." @ %function @ "(";
|
|
%paramOffset = 1;
|
|
}
|
|
else
|
|
{
|
|
if(isMethod(%type, %function))
|
|
{
|
|
%command = %type @ "::" @ %function @ "(";
|
|
%isStaticCall = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(%command $= "")
|
|
{
|
|
//check in case it's a purely static type call with no usual incoming vars.
|
|
//Usually only relevent for create functions
|
|
if($paramCache0 $= "" && $paramCache1 $= "" && isMethod(%type, %function))
|
|
{
|
|
%command = %type @ "::" @ %function @ "(";
|
|
%isStaticCall = true;
|
|
}
|
|
else if(isMethod("GenericAsset", %function))
|
|
{
|
|
%command = "GenericAsset::" @ %function @ "(";
|
|
%isStaticCall = true;
|
|
}
|
|
else
|
|
{
|
|
error("AssetBrowser::callAssetTypeFunc() - unable to find a valid type: " @ %type @ " with function: " @ %function);
|
|
return;
|
|
}
|
|
}
|
|
|
|
for(%i=%paramOffset; %i < 5; %i++)
|
|
{
|
|
%paramVar = getVariable("$paramCache" @ %i);
|
|
if(%paramVar !$= "")
|
|
{
|
|
if(%paramOffset != 0 && %i==%paramOffset && %isStaticCall)
|
|
%command = %command @ ",";
|
|
|
|
if(getWordCount(%paramVar) > 1 || strPos(%paramVar, "/") != 0 || stePos(%paramVar, "\\") != 0)
|
|
%command = %command @ "\"" @ %paramVar @ "\"";
|
|
else
|
|
%command = %command @ %paramVar;
|
|
}
|
|
%nextParamVar = getVariable("$paramCache" @ %i+1);
|
|
if(%nextParamVar !$= "")
|
|
{
|
|
%command = %command @ ",";
|
|
}
|
|
}
|
|
|
|
%command = %command @ ");";
|
|
|
|
//echo("AssetBrowser::callAssetTypeFunc() - executing command: " @ %command);
|
|
|
|
%return = "";
|
|
if(%command !$= "")
|
|
%return = eval(%command);
|
|
|
|
$CurrentAssetBrowser = "";
|
|
|
|
return %return;
|
|
}
|
|
|
|
//
|
|
function AssetBrowser::initialize(%this)
|
|
{
|
|
// manage preview array
|
|
if(!isObject(AssetPreviewArray))
|
|
new ArrayObject(AssetPreviewArray);
|
|
|
|
if(!isObject(ObjectCreator))
|
|
new ScriptObject(ObjectCreator);
|
|
|
|
if(!isObject(%this.dirHandler))
|
|
{
|
|
%this.dirHandler = makedirectoryHandler(%this-->filterTree, "cache,shaderCache", "");
|
|
%this.dirHandler.currentAddress = "data/";
|
|
}
|
|
|
|
%this-->filterTree.buildIconTable( ":tools/classIcons/Prefab:tools/classIcons/Prefab" @
|
|
":tools/classIcons/SimSet:tools/classIcons/SimSet");
|
|
|
|
%this.isReImportingAsset = false;
|
|
|
|
%this.coreModulesFilter = false;
|
|
%this.toolsModulesFilter = false;
|
|
%this.onlyShowModulesWithAssets = false;
|
|
|
|
%this.folderPanelState = true;
|
|
%this.folderPanelSplit = 0;
|
|
|
|
%this.templateFilesPath = "tools/assetBrowser/scripts/templateFiles/";
|
|
|
|
//First, build our our list of active modules
|
|
%modulesList = ModuleDatabase.findModules(true);
|
|
|
|
%this-->previewSlider.setValue(EditorSettings.value("Assets/Browser/previewTileSize", "1.0"));
|
|
|
|
%this-->filterAssetsButton.setActive(true);
|
|
|
|
%this.toggleAssetTypeFilter(0);
|
|
}
|
|
|
|
function AssetBrowser::onAdd(%this)
|
|
{
|
|
}
|
|
|
|
function AssetBrowser::onWake(%this)
|
|
{
|
|
%this.initialize();
|
|
|
|
// Make the window fit next to the side panel
|
|
// We do a simple resize so that we don't have to redo the whole GUI layout
|
|
%newWidth = getWord($pref::Video::mode, 0) - 360;
|
|
%vertPos = getWord($pref::Video::mode, 1) - 360 - 35;
|
|
AssetBrowserWindow.resize("0", %vertPos, %newWidth, "360");
|
|
AssetBrowserWindow.dockPanel();
|
|
}
|
|
|
|
function AssetBrowser::onDialogPop(%this)
|
|
{
|
|
$AssetBrowser::Open = false;
|
|
%lastPosExt = AssetBrowserWindow.position SPC AssetBrowserWindow.extent;
|
|
EditorSettings.setValue("Assets/Browser/LastPosExt", %lastPosExt);
|
|
}
|
|
|
|
function AssetBrowser::onDialogPush(%this)
|
|
{
|
|
$AssetBrowser::Open = true;
|
|
EditorGui.updateSideBar();
|
|
}
|
|
|
|
function AssetBrowser::setTab(%this, %tab, %text, %command)
|
|
{
|
|
if(isObject(%tab))
|
|
{
|
|
%tab.setActive(true);
|
|
%tab.setHidden(false);
|
|
%tab.setText(%text);
|
|
%tab.command = %command;
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::putToFront(%this)
|
|
{
|
|
// Close the object
|
|
%this.hideDialog();
|
|
// Create the object again so it will render on top
|
|
%this.ShowDialog();
|
|
// Put the focus on this window
|
|
%this.restoreLastPosExt();
|
|
AssetBrowserWindow.selectWindow();
|
|
}
|
|
|
|
function AssetBrowser::restoreLastPosExt(%this)
|
|
{
|
|
%lastPosExt = EditorSettings.value("Assets/Browser/LastPosExt", "");
|
|
if(%lastPosExt !$= "")
|
|
{
|
|
AssetBrowserWindow.resize(getWord(%lastPosExt, 0), getWord(%lastPosExt, 1), getWord(%lastPosExt, 2), getWord(%lastPosExt, 3));
|
|
}
|
|
EditorGui.updateSideBar();
|
|
}
|
|
|
|
function contentTreeTabBook::onTabSelected(%this, %tabText, %tabIndex)
|
|
{
|
|
if(%tabText $= "Content")
|
|
{
|
|
//Force it to navigate to current active directory, which also rebuilds the
|
|
//tree
|
|
AssetBrowser.dirHandler.navigateTo(AssetBrowser.dirHandler.currentAddress);
|
|
}
|
|
else
|
|
{
|
|
AssetBrowser-->filterTree.clear();
|
|
AssetBrowser-->filterTree.buildVisibleTree(true);
|
|
}
|
|
}
|
|
|
|
//Filters
|
|
function AssetBrowser::showFilterPopup(%this)
|
|
{
|
|
BrowserVisibilityPopup.showPopup(Canvas);
|
|
}
|
|
|
|
function AssetBrowser::viewCoreModulesFilter(%this)
|
|
{
|
|
%oldVal = EditorSettings.value("Assets/Browser/showCoreModule", false);
|
|
%newVal = !%oldVal;
|
|
|
|
%this.coreModulesFilter = %newVal;
|
|
|
|
BrowserVisibilityPopup.checkItem(0,%newVal);
|
|
|
|
EditorSettings.setValue("Assets/Browser/showCoreModule", %newVal);
|
|
|
|
AssetBrowser.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::viewToolsModulesFilter(%this)
|
|
{
|
|
%oldVal = EditorSettings.value("Assets/Browser/showToolsModule", false);
|
|
%newVal = !%oldVal;
|
|
|
|
%this.toolsModulesFilter = %newVal;
|
|
|
|
BrowserVisibilityPopup.checkItem(1,%newVal);
|
|
|
|
EditorSettings.setValue("Assets/Browser/showToolsModule", %newVal);
|
|
|
|
%this.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::viewPopulatedModulesFilter(%this)
|
|
{
|
|
%oldVal = EditorSettings.value("Assets/Browser/showOnlyPopulatedModule", false);
|
|
%newVal = !%oldVal;
|
|
|
|
BrowserVisibilityPopup.checkItem(2,%newVal);
|
|
|
|
EditorSettings.setValue("Assets/Browser/showOnlyPopulatedModule", %newVal);
|
|
|
|
%this.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::toggleShowingFolders(%this)
|
|
{
|
|
%oldVal = EditorSettings.value("Assets/Browser/showFolders", false);
|
|
%newVal = !%oldVal;
|
|
|
|
BrowserVisibilityPopup.checkItem(4,%newVal);
|
|
|
|
EditorSettings.setValue("Assets/Browser/showFolders", %newVal);
|
|
|
|
%this.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::toggleShowingEmptyFolders(%this)
|
|
{
|
|
%oldVal = EditorSettings.value("Assets/Browser/showEmptyFolders", false);
|
|
%newVal = !%oldVal;
|
|
|
|
BrowserVisibilityPopup.checkItem(5,%newVal);
|
|
|
|
EditorSettings.setValue("Assets/Browser/showEmptyFolders", %newVal);
|
|
|
|
%this.refresh();
|
|
}
|
|
|
|
function AssetBrowser::toggleAssetTypeFilter(%this, %assetTypeIdx)
|
|
{
|
|
%isChecked = AssetTypeListPopup.isItemChecked(%assetTypeIdx);
|
|
|
|
//Clear existing filters
|
|
if(%assetTypeIdx == 0)
|
|
{
|
|
for(%i=0; %i < ABAssetTypesList.Count(); %i++)
|
|
{
|
|
AssetTypeListPopup.checkItem(%i+2, false);
|
|
}
|
|
|
|
AssetTypeListPopup.checkItem(0, true);
|
|
}
|
|
else if(%assetTypeIdx > 1) //slot 1 is the divider so ignore it
|
|
{
|
|
if(%isChecked)
|
|
{
|
|
%anyOtherFilters = false;
|
|
for(%i=0; %i < ABAssetTypesList.Count(); %i++)
|
|
{
|
|
if(%assetTypeIdx == %i+2)
|
|
continue;
|
|
|
|
if(AssetTypeListPopup.isItemChecked(%i+1))
|
|
{
|
|
%anyOtherFilters = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(%isChecked && !%anyOtherFilters)
|
|
{
|
|
for(%i=0; %i < ABAssetTypesList.Count(); %i++)
|
|
{
|
|
AssetTypeListPopup.checkItem(%i+2, false);
|
|
}
|
|
|
|
AssetTypeListPopup.checkItem(0, true);
|
|
}
|
|
else
|
|
{
|
|
AssetTypeListPopup.checkItem(0, false);
|
|
AssetTypeListPopup.checkItem(%assetTypeIdx, !%isChecked);
|
|
}
|
|
}
|
|
|
|
//Update the displayed search text!
|
|
//First, clear out the old type search term
|
|
for(%i=0; %i < AssetSearchTerms.count(); %i++)
|
|
{
|
|
%action = AssetSearchTerms.getKey(%i);
|
|
|
|
if(%action $= "type")
|
|
{
|
|
AssetSearchTerms.erase(%i);
|
|
%i--;
|
|
}
|
|
}
|
|
|
|
for(%i=2; %i < AssetTypeListPopup.getItemCount(); %i++)
|
|
{
|
|
%isChecked = AssetTypeListPopup.isItemChecked(%i);
|
|
if(!%isChecked)
|
|
continue;
|
|
|
|
%typeListText = AssetTypeListPopup.getItemText(%i);
|
|
|
|
for(%t=0; %t < ABAssetTypesList.Count(); %t++)
|
|
{
|
|
%typeData = ABAssetTypesList.getValue(%t);
|
|
%typeName = getField(%typeData, 1);
|
|
|
|
if(%typeListText $= %typeName)
|
|
{
|
|
AssetSearchTerms.add("type", getField(%typeData, 0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
%this.updateSearchTextFromFilter();
|
|
|
|
%this.rebuildAssetArray();
|
|
}
|
|
|
|
//
|
|
function AssetBrowser::selectAsset( %this, %asset )
|
|
{
|
|
if(%this.selectCallback !$= "")
|
|
{
|
|
// The callback function should be ready to intake the returned material
|
|
//eval("materialEd_previewMaterial." @ %propertyField @ " = " @ %value @ ";");
|
|
if( %this.returnType $= "name" )
|
|
{
|
|
// TODO!
|
|
%name = "";
|
|
eval( "" @ %this.selectCallback @ "(" @ %name @ ");");
|
|
}
|
|
else
|
|
{
|
|
%command = "" @ %this.selectCallback @ "(\"" @ %asset @ "\");";
|
|
eval(%command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//try just setting the asset
|
|
%this.changeAsset();
|
|
}
|
|
|
|
if(isObject(Inspector))
|
|
Inspector.refresh();
|
|
|
|
%this.hideDialog();
|
|
}
|
|
|
|
function AssetBrowser::showDialog( %this, %AssetTypeFilter, %selectCallback, %targetObj, %fieldName, %returnType)
|
|
{
|
|
// Set the select callback
|
|
%this.selectCallback = %selectCallback;
|
|
%this.returnType = %returnType;
|
|
%this.assetTypeFilter = %AssetTypeFilter;
|
|
%this.fieldTargetObject = %targetObj;
|
|
%this.fieldTargetName = %fieldName;
|
|
|
|
Canvas.popDialog(%this);
|
|
Canvas.pushDialog(%this);
|
|
|
|
%this.setVisible(1);
|
|
AssetBrowserWindow.setVisible(1);
|
|
AssetBrowserWindow.selectWindow();
|
|
|
|
if(AssetBrowserWindow.docked)
|
|
AssetBrowserWindow.dockPanel();
|
|
else
|
|
AssetBrowserWindow.releasePanel();
|
|
|
|
//If we're special-case filtering(like for selecting a given type), then ignore our normal
|
|
//visibility filter
|
|
if(%AssetTypeFilter !$= "")
|
|
{
|
|
%this-->filterAssetsButton.setActive(false);
|
|
}
|
|
else
|
|
{
|
|
%this-->filterAssetsButton.setActive(true);
|
|
}
|
|
|
|
if(%selectCallback $= "")
|
|
{
|
|
//we're not in selection mode, so just hide the select button
|
|
%this-->SelectButton.setHidden(true);
|
|
%this.selectMode = 0;
|
|
}
|
|
else
|
|
{
|
|
%this-->SelectButton.setHidden(false);
|
|
%this.selectMode = 1;
|
|
}
|
|
|
|
%this.loadDirectories();
|
|
|
|
%this.restoreLastPosExt();
|
|
}
|
|
|
|
function AssetBrowser::hideDialog( %this )
|
|
{
|
|
%this.setVisible(1);
|
|
AssetBrowserWindow.setVisible(1);
|
|
Canvas.popDialog(AssetBrowser_addModule);
|
|
Canvas.popDialog(ImportAssetWindow);
|
|
|
|
Canvas.popDialog(%this);
|
|
}
|
|
|
|
function AssetBrowser::toggleDialog( %this )
|
|
{
|
|
if(%this.isAwake())
|
|
{
|
|
%this.hideDialog();
|
|
}
|
|
else
|
|
{
|
|
%this.showDialog();
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
|
|
{
|
|
if(!isObject(%this.previewData))
|
|
{
|
|
%this.previewData = new ScriptObject();
|
|
}
|
|
else
|
|
{
|
|
%this.previewData.tooltip = "";
|
|
%this.previewData.assetName = "";
|
|
%this.previewData.previewImage = "";
|
|
%this.previewData.doubleClickCommand = "";
|
|
}
|
|
|
|
%previewImage = "core/art/warnmat";
|
|
|
|
if(/*%moduleName !$= "" && */ModuleDatabase.findModule(%moduleName, 1) !$= "")
|
|
{
|
|
%assetDesc = AssetDatabase.acquireAsset(%asset);
|
|
%assetName = AssetDatabase.getAssetName(%asset);
|
|
%assetType = AssetDatabase.getAssetType(%asset);
|
|
}
|
|
else
|
|
{
|
|
//special-case entry
|
|
if(getFieldCount(%asset) > 1)
|
|
{
|
|
%assetType = getField(%asset,0);
|
|
%assetName = getField(%asset, 1);
|
|
|
|
if(%assetType $= "Creator")
|
|
{
|
|
%assetDesc = %assetName;
|
|
%assetDesc.assetType = %assetType;
|
|
%moduleName = %assetDesc;
|
|
}
|
|
}
|
|
}
|
|
|
|
%previewSize = 100 SPC 100;
|
|
%previewBounds = 20;
|
|
|
|
%tooltip = %assetName;
|
|
|
|
%textBottomPad = 20;
|
|
|
|
%previewButton = new GuiIconButtonCtrl()
|
|
{
|
|
class = "AssetBrowserPreviewButton";
|
|
useMouseEvents = true;
|
|
iconLocation = "Center";
|
|
sizeIconToButton = true;
|
|
makeIconSquare = true;
|
|
textLocation = "Bottom";
|
|
extent = %previewSize.x SPC %previewSize.y + %textBottomPad;
|
|
buttonType = "RadioButton";
|
|
buttonMargin = "0 -10";
|
|
profile = ToolsGuiDefaultIconBtnProfile;
|
|
assetBrowser = %this;
|
|
};
|
|
|
|
%previewScaleSize = %this-->previewSlider.getValue();
|
|
|
|
if(%previewScaleSize $= "")
|
|
{
|
|
%previewScaleSize = 1;
|
|
%this-->previewSlider.setValue(1);
|
|
}
|
|
|
|
if(%previewScaleSize == 0 || startsWith(%this.dirHandler.currentAddress, "Creator"))
|
|
{
|
|
%previewButton.iconLocation = "Left";
|
|
%previewButton.textLocation = "Right";
|
|
%previewButton.setextent(160,34);
|
|
%previewButton.buttonMargin = "8 8";
|
|
%previewButton.textMargin = "6";
|
|
|
|
%this.previewListMode = true;
|
|
}
|
|
else
|
|
{
|
|
%size = %previewSize.x * %previewScaleSize;
|
|
%previewButton.setextent(%size,%size + %textBottomPad);
|
|
|
|
%this.previewListMode = false;
|
|
}
|
|
|
|
//%previewButton.extent = %previewSize.x + %previewBounds SPC %previewSize.y + %previewBounds + 24;
|
|
%previewButton.assetName = %assetName;
|
|
%previewButton.moduleName = %moduleName;
|
|
%previewButton.assetType = %assetType;
|
|
|
|
if(%this.selectMode)
|
|
{
|
|
%doubleClickCommand = %this @ ".selectAsset( "@ %this @ ".selectedAsset );";
|
|
}
|
|
else
|
|
{
|
|
%doubleClickCommand = %this @ ".callAssetTypeFunc(" @ %assetType @ ", \"onEdit\", \"" @ %moduleName @ "\", \"" @ %assetName @ "\" );";
|
|
}
|
|
|
|
%this.previewData.previewLoaded = true;
|
|
|
|
//echo("AssetBrowser::buildAssetPreview() - building preview of asset type: " @ %assetType);
|
|
%this.callAssetTypeFunc(%assetType, "buildBrowserElement", %moduleName, %assetName, %this.previewData);
|
|
|
|
//debug dump
|
|
%tooltip = %this.previewData.tooltip;
|
|
%assetName = %this.previewData.assetName;
|
|
%previewImage = %this.previewData.previewImage;
|
|
|
|
if(%this.previewData.doubleClickCommand !$= "")
|
|
%doubleClickCommand = %this.previewData.doubleClickCommand;
|
|
|
|
%previewButton.assetName = %assetName;
|
|
%previewButton.moduleName = %moduleName;
|
|
%previewButton.assetType = %assetType;
|
|
%previewButton.assetBrowser = %this;
|
|
|
|
%previewButton.bitmapAsset = %this.previewData.previewImage;
|
|
|
|
%previewButton.profile = "AssetBrowserPreview" @ %previewButton.assetType;
|
|
%previewButton.tooltip = %this.previewData.tooltip;
|
|
%previewButton.Command = %this @ ".updateSelection( $ThisControl.assetName, $ThisControl.moduleName );";
|
|
%previewButton.altCommand = %doubleClickCommand;
|
|
|
|
%previewButton.text = %this.previewData.assetName;
|
|
%previewButton.text.originalAssetName = %this.previewData.assetName;
|
|
|
|
// add to the gui control array
|
|
%this-->assetList.add(%previewButton);
|
|
|
|
// add to the array object for reference later
|
|
if(%this.previewData.previewLoaded == false)
|
|
AssetPreviewArray.add( %previewButton );
|
|
}
|
|
|
|
function AssetBrowser::refresh(%this)
|
|
{
|
|
if(!%this.dirty)
|
|
{
|
|
%this.dirty = true;
|
|
|
|
%this.schedule(1, "doRefresh");
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::doRefresh(%this)
|
|
{
|
|
if(%this.dirty)
|
|
{
|
|
%this.navigateTo(%this.dirHandler.currentAddress);
|
|
|
|
//Forces a clean collapse of the tree for any not-really-exposed items
|
|
%dataItem = %this-->filterTree.findItemByName("data");
|
|
|
|
if(%dataItem != 0)
|
|
{
|
|
%this-->filterTree.expandItem(%dataItem, false);
|
|
%this-->filterTree.expandItem(%dataItem);
|
|
}
|
|
|
|
%this.dirty = false;
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::populatePreviewImages(%this)
|
|
{
|
|
if (AssetPreviewArray.count()>0)
|
|
echo("AssetBrowser::populatePreviewImages() - Previews to generate: " @ AssetPreviewArray.count());
|
|
|
|
for(%i=0; %i < AssetPreviewArray.count(); %i++)
|
|
{
|
|
%previewButton = AssetPreviewArray.getKey(%i);
|
|
%assetType = %previewButton.assetType;
|
|
|
|
echo(" - Generating preview for asset: " @ %previewButton.moduleName @ ":" @ %previewButton.assetName);
|
|
|
|
%this.callAssetTypeFunc(%assetType, "generatePreviewImage", %previewButton.moduleName, %previewButton.assetName, %previewButton);
|
|
|
|
AssetPreviewArray.erase(%i);
|
|
|
|
echo(" - done, scheduling another pass");
|
|
%this.schedule(32, "populatePreviewImages");
|
|
return;
|
|
}
|
|
}
|
|
//
|
|
//
|
|
/*function AssetPreviewButton::onClick(%this)
|
|
{
|
|
echo("CLICKED AN ASSET PREVIEW BUTTON");
|
|
}
|
|
|
|
function AssetPreviewButton::onDoubleClick(%this)
|
|
{
|
|
echo("DOUBLE CLICKED AN ASSET PREVIEW BUTTON");
|
|
}*/
|
|
//
|
|
//
|
|
|
|
function assetBrowserPreviewSlider::onMouseDragged(%this)
|
|
{
|
|
EditorSettings.setValue("Assets/Browser/previewTileSize", %this.getValue());
|
|
AssetBrowser.refresh();
|
|
}
|
|
|
|
function AssetBrowser::loadDirectories( %this )
|
|
{
|
|
%this-->filterTree.clear();
|
|
|
|
%dataItem = AssetBrowser-->filterTree.insertItem(0, "Content");
|
|
%this-->filterTree.collectionsIdx = %this-->filterTree.insertItem(1, "Collections");
|
|
|
|
%this-->filterTree.modulesIdx = %this-->filterTree.insertItem(1, "Modules");
|
|
|
|
%dataItem = AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.modulesIdx, "data");
|
|
%this-->filterTree.tagsIdx = %this-->filterTree.insertItem(1, "Tags");
|
|
|
|
%this-->filterTree.creatorIdx = %this-->filterTree.insertItem(1, "Creator");
|
|
|
|
%this-->filterTree.clearSelection();
|
|
|
|
if(%this.selectMode)
|
|
{
|
|
//Due to a fluke in how this tracks, it overrides the current addres, so we'll
|
|
//store it real fast
|
|
%curAdd = %this.dirHandler.currentAddress;
|
|
|
|
//Disable these for this go
|
|
%this-->filterTree.addSelection(%this-->filterTree.collectionsIdx);
|
|
%this-->filterTree.addSelection(%this-->filterTree.creatorIdx);
|
|
%this-->filterTree.hideSelection();
|
|
%this-->filterTree.clearSelection();
|
|
|
|
%this.dirHandler.currentAddress = %curAdd;
|
|
}
|
|
|
|
%this.dirHandler.loadFolders("data", %dataItem);
|
|
|
|
%this.loadCollectionSets();
|
|
|
|
%this.loadTags();
|
|
|
|
if (!%this.selectMode)
|
|
%this.loadCreatorClasses();
|
|
|
|
//If set to, show core
|
|
if(EditorSettings.value("Assets/Browser/showCoreModule", false) == 1)
|
|
{
|
|
%coreItem = %this-->filterTree.insertItem(%this-->filterTree.modulesIdx, "core");
|
|
%this.dirHandler.loadFolders("core", %coreItem);
|
|
}
|
|
|
|
//If set to, show tools
|
|
if(EditorSettings.value("Assets/Browser/showToolsModule", false) == 1)
|
|
{
|
|
%toolsItem = %this-->filterTree.insertItem(%this-->filterTree.modulesIdx, "tools");
|
|
%this.dirHandler.loadFolders("tools", %toolsItem);
|
|
}
|
|
|
|
%this-->filterTree.buildVisibleTree(true);
|
|
|
|
//Remove any modules that have no assets if we have that filter on
|
|
if(%this.onlyShowModulesWithAssets)
|
|
{
|
|
%modulesList = ModuleDatabase.findModules();
|
|
for(%i=0; %i < getWordCount(%modulesList); %i++)
|
|
{
|
|
%moduleName = getWord(%modulesList, %i).ModuleId;
|
|
|
|
%moduleItemId = %this-->filterTree.findItemByName(%moduleName);
|
|
|
|
if(%this-->filterTree.isParentItem(%moduleItemId) == false)
|
|
%this-->filterTree.removeItem(%moduleItemId);
|
|
}
|
|
}
|
|
|
|
//special handling for selections
|
|
if(%this.newModuleId !$= "")
|
|
{
|
|
%this-->filterTree.clearSelection();
|
|
%newModuleItem = %this-->filterTree.findItemByName(%this.newModuleId);
|
|
%this-->filterTree.selectItem(%newModuleItem);
|
|
%this.newModuleId = "";
|
|
}
|
|
|
|
%this.dirHandler.expandTreeToAddress(%this.dirHandler.currentAddress);
|
|
|
|
%selectedItem = %this.dirHandler.getFolderTreeItemFromAddress(%this.dirHandler.currentAddress);
|
|
%this-->filterTree.scrollVisibleByObjectId(%selectedItem);
|
|
|
|
%this-->filterTree.buildVisibleTree(true);
|
|
|
|
%this.refresh();
|
|
}
|
|
|
|
function AssetBrowser::updateSelection( %this, %asset, %moduleName )
|
|
{
|
|
//If we had an existing selected assetDef, clear the reference
|
|
if(isObject(AssetBrowser.selectedAssetDef))
|
|
AssetDatabase.releaseAsset(AssetBrowser.selectedAssetDef.getAssetId());
|
|
|
|
//AssetBrowser.selectedMaterial = %asset;
|
|
AssetBrowser.selectedAsset = %moduleName@":"@%asset;
|
|
|
|
//If it's got slashes, it's a path so it's actually a folder item, not an asset
|
|
if(strstr(%moduleName, "/") != -1)
|
|
return;
|
|
|
|
//Check if this is an actual assetId, or if it's just a programmatic reference
|
|
//like what we use for the creator entries
|
|
if(AssetDatabase.isDeclaredAsset(AssetBrowser.selectedAsset))
|
|
{
|
|
//Looks good, it's an asset so we'll select the definition while we're at it
|
|
AssetBrowser.selectedAssetDef = AssetDatabase.acquireAsset(AssetBrowser.selectedAsset);
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::loadCollectionSets(%this)
|
|
{
|
|
//Process any datablocks and populate their lists categories as tags as well
|
|
%collectionsItem = AssetBrowser-->filterTree.collectionsIdx;
|
|
|
|
%collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
|
|
|
|
for ( %i = 0; %i < %collectionsCount; %i++ )
|
|
{
|
|
%collection = AssetBrowserCollectionSets.value("Collection"@%i, "");
|
|
%collectionName = getField(%collection, 0);
|
|
%collectionTerm = getField(%collection, 1);
|
|
|
|
AssetBrowser-->filterTree.insertItem(%collectionsItem, %collectionName, %collectionTerm);
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::setCollectionSetActive(%this, %collectionSet)
|
|
{
|
|
AssetBrowserSearchFilter.setText(%collectionSet);
|
|
AssetBrowserSearchFilter.onReturn();
|
|
}
|
|
|
|
function AssetBrowser::loadTags(%this)
|
|
{
|
|
//Process any datablocks and populate their lists categories as tags as well
|
|
%dataGroup = "DataBlockGroup";
|
|
%tagItem = AssetBrowser-->filterTree.tagsIdx;
|
|
|
|
for ( %i = 0; %i < %dataGroup.getCount(); %i++ )
|
|
{
|
|
%obj = %dataGroup.getObject(%i);
|
|
// echo ("Obj: " @ %obj.getName() @ " - " @ %obj.category );
|
|
|
|
if ( %obj.category $= "" && %obj.category == 0 )
|
|
continue;
|
|
|
|
%tagChildItem = AssetBrowser-->filterTree.findChildItemByName(%tagItem, %obj.category);
|
|
if(%tagChildItem == 0)
|
|
{
|
|
//Didn't already exist, so register it in
|
|
AssetBrowser-->filterTree.insertItem(%tagItem, %obj.category);
|
|
}
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::setTagActive(%this, %tag)
|
|
{
|
|
%found = false;
|
|
|
|
for(%i=0; %i < AssetSearchTerms.count(); %i++)
|
|
{
|
|
%action = AssetSearchTerms.getKey(%i);
|
|
%word = AssetSearchTerms.getValue(%i);
|
|
|
|
if(%action $= "tag" && %word $= %tag)
|
|
{
|
|
//If we found it, we just remove it from our list, toggling it off
|
|
AssetSearchTerms.erase(%i);
|
|
%found = true;
|
|
}
|
|
}
|
|
|
|
//If we didn't find it, we're going to add it into our list
|
|
if(!%found)
|
|
{
|
|
AssetSearchTerms.add("tag", %tag);
|
|
}
|
|
|
|
%this.updateSearchTextFromFilter();
|
|
|
|
%this.rebuildAssetArray();
|
|
}
|
|
|
|
//
|
|
//needs to be deleted with the persistence manager and needs to be blanked out of the matmanager
|
|
//also need to update instances... i guess which is the tricky part....
|
|
function AssetBrowser::showDeleteDialog( %this )
|
|
{
|
|
%material = AssetBrowser.selectedAsset;
|
|
%secondFilter = "MaterialFilterMappedArray";
|
|
%secondFilterName = "Mapped";
|
|
|
|
for( %i = 0; %i < MaterialFilterUnmappedArray.count(); %i++ )
|
|
{
|
|
if( MaterialFilterUnmappedArray.getValue(%i) $= %material )
|
|
{
|
|
%secondFilter = "MaterialFilterUnmappedArray";
|
|
%secondFilterName = "Unmapped";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( isObject( %material ) )
|
|
{
|
|
toolsMessageBoxYesNoCancel("Delete Material?",
|
|
"Are you sure you want to delete<br><br>" @ %material.getName() @ "<br><br> Material deletion won't take affect until the engine is quit.",
|
|
"AssetBrowser.deleteMaterial( " @ %material @ ", " @ %secondFilter @ ", " @ %secondFilterName @" );",
|
|
"",
|
|
"" );
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::deleteMaterial( %this, %materialName, %secondFilter, %secondFilterName )
|
|
{
|
|
if( !isObject( %materialName ) )
|
|
return;
|
|
|
|
for( %i = 0; %i <= MaterialFilterAllArray.countValue( %materialName ); %i++)
|
|
{
|
|
%index = MaterialFilterAllArray.getIndexFromValue( %materialName );
|
|
MaterialFilterAllArray.erase( %index );
|
|
}
|
|
MaterialFilterAllArrayCheckbox.setText("All ( " @ MaterialFilterAllArray.count() - 1 @ " ) ");
|
|
|
|
%checkbox = %secondFilter @ "Checkbox";
|
|
for( %k = 0; %k <= %secondFilter.countValue( %materialName ); %k++)
|
|
{
|
|
%index = %secondFilter.getIndexFromValue( %materialName );
|
|
%secondFilter.erase( %index );
|
|
}
|
|
%checkbox.setText( %secondFilterName @ " ( " @ %secondFilter.count() - 1 @ " ) ");
|
|
|
|
for( %i = 0; %materialName.getFieldValue("materialTag" @ %i) !$= ""; %i++ )
|
|
{
|
|
%materialTag = %materialName.getFieldValue("materialTag" @ %i);
|
|
|
|
for( %j = AssetBrowser.staticFilterObjects; %j < AssetBrowser-->filterArray.getCount() ; %j++ )
|
|
{
|
|
if( %materialTag $= AssetBrowser-->filterArray.getObject(%j).getObject(0).filter )
|
|
{
|
|
%count = getWord( AssetBrowser-->filterArray.getObject(%j).getObject(0).getText(), 2 );
|
|
%count--;
|
|
AssetBrowser-->filterArray.getObject(%j).getObject(0).setText( %materialTag @ " ( "@ %count @ " )");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
UnlistedMaterials.add( "unlistedMaterials", %materialName );
|
|
|
|
if( %materialName.getFilename() !$= "" &&
|
|
%materialName.getFilename() !$= "tools/gui/AssetBrowser.ed.gui" &&
|
|
%materialName.getFilename() !$= "tools/materialEditor/scripts/materialEditor.ed." @ $TorqueScriptFileExtension )
|
|
{
|
|
AssetBrowserPerMan.removeObjectFromFile(%materialName);
|
|
AssetBrowserPerMan.saveDirty();
|
|
}
|
|
|
|
AssetBrowser.refresh();
|
|
}
|
|
|
|
function AssetBrowser::toggleTagFilterPopup(%this)
|
|
{
|
|
if(TagFilterWindow.visible)
|
|
TagFilterWindow.visible = false;
|
|
else
|
|
TagFilterWindow.visible = true;
|
|
|
|
return;
|
|
%assetQuery = new AssetQuery();
|
|
%numAssetsFound = AssetDatabase.findAllAssets(%assetQuery);
|
|
|
|
for( %i=0; %i < %numAssetsFound; %i++)
|
|
{
|
|
%assetId = %assetQuery.getAsset(%i);
|
|
|
|
//first, get the asset's module, as our major categories
|
|
%module = AssetDatabase.getAssetModule(%assetId);
|
|
|
|
%moduleName = %module.moduleId;
|
|
|
|
//check that we don't re-add it
|
|
%moduleItemId = AssetBrowser-->filterTree.findItemByName(%moduleName);
|
|
|
|
if(%moduleItemId == -1 || %moduleItemId == 0)
|
|
%moduleItemId = AssetBrowser-->filterTree.insertItem(1, %module.moduleId, "", "", 1, 2);
|
|
|
|
//now, add the asset's category
|
|
%assetType = AssetDatabase.getAssetCategory(%assetId);
|
|
|
|
// TODO?
|
|
%text = "";
|
|
%var = "";
|
|
%cmd = "";
|
|
%textLength = strlen(%text);
|
|
// end todo
|
|
|
|
%checkBox = new GuiCheckBoxCtrl()
|
|
{
|
|
canSaveDynamicFields = "0";
|
|
isContainer = "0";
|
|
Profile = "ToolsGuiCheckBoxListProfile";
|
|
HorizSizing = "right";
|
|
VertSizing = "bottom";
|
|
Position = "0 0";
|
|
Extent = (%textLength * 4) @ " 18";
|
|
MinExtent = "8 2";
|
|
canSave = "1";
|
|
Visible = "1";
|
|
Variable = %var;
|
|
tooltipprofile = "ToolsGuiToolTipProfile";
|
|
hovertime = "1000";
|
|
text = %text;
|
|
groupNum = "-1";
|
|
buttonType = "ToggleButton";
|
|
useMouseEvents = "0";
|
|
useInactiveState = "0";
|
|
Command = %cmd;
|
|
};
|
|
|
|
TagFilterList.add(%checkBox);
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::changeAsset(%this)
|
|
{
|
|
%targetObject = %this.fieldTargetObject;
|
|
%inspectorObject = "";
|
|
|
|
if(isObject(%this.fieldTargetObject) && %this.fieldTargetObject.isInNamespaceHierarchy("GuiInspector"))
|
|
{
|
|
%inspectorObject = %this.fieldTargetObject;
|
|
if(%inspectorObject.getNumInspectObjects() != 0)
|
|
{
|
|
%targetObject = %inspectorObject.getInspectObject();
|
|
%inspectorObject.setObjectField(%this.fieldTargetName, %this.selectedAsset);
|
|
}
|
|
else if(startsWith(%this.fieldTargetName, "$"))
|
|
{
|
|
//we're targeting a variable directly, so deal with that then
|
|
%cmd = %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
|
|
}
|
|
}
|
|
else if(isObject(%this.fieldTargetObject))
|
|
{
|
|
//alright, we've selectd an asset for a field, so time to set it!
|
|
if(%this.fieldTargetName $= "")
|
|
%cmd = %targetObject @ ".apply(\""@ %this.selectedAsset @ "\");";
|
|
else
|
|
%cmd = %targetObject @ "." @ %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
|
|
//echo("Changing asset via the " @ %cmd @ " command");
|
|
}
|
|
else if(startsWith(%this.fieldTargetName, "$"))
|
|
{
|
|
//we're targeting a variable directly, so deal with that then
|
|
%cmd = %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
|
|
}
|
|
|
|
eval(%cmd);
|
|
|
|
//Force update our object with the field change
|
|
if(isObject(%targetObject))
|
|
{
|
|
if(%this.fieldTargetObject.isInNamespaceHierarchy("GuiInspector"))
|
|
%this.fieldTargetObject.refresh();
|
|
else
|
|
%targetObject.inspectPostApply();
|
|
}
|
|
|
|
//Flag us as dirty for editing purposes
|
|
EWorldEditor.setSceneAsDirty();
|
|
}
|
|
|
|
function AssetBrowser::reImportAsset(%this)
|
|
{
|
|
//Find out what type it is
|
|
%assetDef = AssetDatabase.acquireAsset(EditAssetPopup.assetId);
|
|
%assetType = AssetDatabase.getAssetType(EditAssetPopup.assetId);
|
|
|
|
if(%assetType $= "ShapeAsset" || %assetType $= "ImageAsset" || %assetType $= "SoundAsset")
|
|
{
|
|
AssetBrowser.isAssetReImport = true;
|
|
AssetBrowser.reImportingAssetId = EditAssetPopup.assetId;
|
|
|
|
%reimportingPath = %assetDef.originalFilePath;
|
|
|
|
if(%reimportingPath $= "" || !isFile(%reimportingPath))
|
|
{
|
|
//if we have no defined original file path, attempt to re-import the
|
|
//current loosefile
|
|
if(%assetType $= "ShapeAsset")
|
|
%reimportingPath = %assetDef.getShapePath();
|
|
else if(%assetType $= "ImageAsset")
|
|
%reimportingPath = %assetDef.getImagePath();
|
|
else if(%assetType $= "SoundAsset")
|
|
%reimportingPath = %assetDef.getSoundPath();
|
|
}
|
|
|
|
//first, double-check we have an originating file. if we don't then we need to basically go out looking for it
|
|
if(!isFile(%reimportingPath))
|
|
{
|
|
//if(%assetType $= "ImageAsset")
|
|
// %filters = "";
|
|
|
|
//TODO
|
|
%currentFile = "";
|
|
|
|
%dlg = new OpenFileDialog()
|
|
{
|
|
Filters = "(All Files (*.*)|*.*|";
|
|
DefaultFile = %currentFile;
|
|
ChangePath = false;
|
|
MustExist = true;
|
|
MultipleFiles = false;
|
|
forceRelativePath = false;
|
|
};
|
|
|
|
if ( %dlg.Execute() )
|
|
{
|
|
%reimportingPath = %dlg.FileName;
|
|
}
|
|
|
|
%dlg.delete();
|
|
}
|
|
|
|
AssetBrowser.onBeginDropFiles();
|
|
AssetBrowser.onDropFile(%reimportingPath);
|
|
AssetBrowser.onEndDropFiles();
|
|
|
|
%module = AssetDatabase.getAssetModule(EditAssetPopup.assetId);
|
|
|
|
//get the selected module data
|
|
ImportAssetModuleList.setText(%module.ModuleId);
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// RMB context popups
|
|
function AssetBrowserPreviewButton::onRightClick(%this)
|
|
{
|
|
%this.assetBrowser.selectedAssetPreview = %this;
|
|
%this.assetBrowser.callAssetTypeFunc(%this.assetType, "onShowActionMenu", %this.moduleName, %this.assetName);
|
|
}
|
|
|
|
//function AssetListPanel::onRightMouseDown(%this)
|
|
function AssetListPanelInputs::onRightMouseDown(%this)
|
|
{
|
|
AddNewAssetPopup.showPopup(Canvas);
|
|
}
|
|
|
|
function AssetBrowserFilterTree::onRightMouseDown(%this, %itemId)
|
|
{
|
|
%count = %this.getSelectedItemsCount();
|
|
|
|
%itemText = %this.getItemText(%itemId);
|
|
%parentItem = %this.getParentItem(%itemId);
|
|
if(%parentItem == %this.tagsIdx)
|
|
{
|
|
}
|
|
else if(%parentItem == %this.collectionsIdx)
|
|
{
|
|
EditCollectionSets.showPopup(Canvas);
|
|
AssetBrowser.selectedCollectionSet = %itemText;
|
|
}
|
|
else if(%parentItem == %this.creatorIdx)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if( %this.getSelectedItemsCount() > 0 && (%itemText !$= "data" && %itemText !$="core" && %itemText !$= "tools"))
|
|
{
|
|
//AddNewAssetPopup.showPopup(Canvas);
|
|
|
|
//We have something clicked, so figure out if it's a sub-filter or a module filter, then push the correct
|
|
//popup menu
|
|
%parentItem = %this.getParentItem(%itemId);
|
|
if(%this.getItemText(%parentItem) $= "data") //if it's a data module, continue
|
|
{
|
|
//find out if it's a folder or a module!
|
|
if(ModuleDatabase.findModule(%itemText))
|
|
{
|
|
//yep, module, push the all-inclusive popup
|
|
EditModulePopup.showPopup(Canvas);
|
|
//also set the module value for creation info
|
|
AssetBrowser.selectedModule = %itemText;
|
|
}
|
|
else
|
|
{
|
|
EditNonModulePopup.showPopup(Canvas);
|
|
EditNonModulePopup.targetFolder = %itemText;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditFolderPopup.showPopup(Canvas);
|
|
EditFolderPopup.assetType = "Folder";
|
|
}
|
|
}
|
|
else if(%itemText $= "data")
|
|
{
|
|
AddNewModulePopup.showPopup(Canvas);
|
|
}
|
|
else if(%itemText $= "tools")
|
|
{
|
|
AddNewToolPopup.showPopup(Canvas);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
function AssetBrowser::openAssetSettings(%this)
|
|
{
|
|
ESettingsWindow.toggleEditorSettings();
|
|
%assetEditIndex = ESettingsWindowList.findTextIndex("Asset Editing");
|
|
ESettingsWindowList.setSelectedRow( %assetEditIndex );
|
|
}
|
|
|
|
function ESettingsWindow::getAssetManagementSettings(%this)
|
|
{
|
|
SettingsInspector.startGroup("Modules");
|
|
SettingsInspector.addSettingsField("AssetManagement/Modules/coreModulePath", "Core Module Path", "string", "");
|
|
SettingsInspector.addSettingsField("AssetManagement/Modules/gameDataModulePath", "Game Data Module Path", "string", "");
|
|
SettingsInspector.addSettingsField("AssetManagement/Modules/moduleExtension", "Module Extension", "string", "");
|
|
|
|
%moduleList = ModuleDatabase.findModules(true);
|
|
%moduleList = strreplace(%moduleList, " ", ",");
|
|
|
|
SettingsInspector.addSettingsField("AssetManagement/Modules/DefaultModule", "Default Module", "list", %moduleList);
|
|
SettingsInspector.endGroup();
|
|
|
|
SettingsInspector.startGroup("Assets");
|
|
SettingsInspector.addSettingsField("AssetManagement/Assets/assetExtension", "Asset Extension", "string", "");
|
|
SettingsInspector.addSettingsField("AssetManagement/Assets/datablockCaching", "Cache Datablocks", "bool", "");
|
|
//SettingsInspector.addSettingsField("AssetManagement/Assets/moduleExtension", "Module Extension", "string", "");
|
|
|
|
SettingsInspector.endGroup();
|
|
}
|
|
|
|
function ESettingsWindow::getAssetEditingSettings(%this)
|
|
{
|
|
ImportAssetWindow::reloadImportOptionConfigs();
|
|
|
|
//First, get our list of modules
|
|
%moduleList = ModuleDatabase.findModules();
|
|
%formattedModuleList = "";
|
|
|
|
%count = getWordCount(%moduleList);
|
|
for(%i=0; %i < %count; %i++)
|
|
{
|
|
%module = getWord(%moduleList, %i);
|
|
if(%module.group !$= "Tools" && %module.group !$= "Core")
|
|
{
|
|
if(%formattedModuleList $= "")
|
|
%formattedModuleList = %module.moduleId;
|
|
else
|
|
%formattedModuleList = %formattedModuleList @ "," @ %module.moduleId;
|
|
}
|
|
}
|
|
|
|
SettingsInspector.startGroup("Asset Creation");
|
|
SettingsInspector.addSettingsField("Assets/New/defaultModule", "Default Module", "list", "Default Module for new assets to be created into", %formattedModuleList);
|
|
SettingsInspector.addSettingsField("Assets/New/alwaysPromptModuleTarget", "Always Prompt Target Module", "bool", "If off, use the default module");
|
|
SettingsInspector.endGroup();
|
|
|
|
%formattedConfigList = "";
|
|
for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
|
|
{
|
|
%configName = ImportAssetWindow.importConfigsList.getKey(%i);
|
|
%formattedConfigList = %i == 0 ? %configName : %formattedConfigList @ "," @ %configName;
|
|
}
|
|
|
|
SettingsInspector.startGroup("Assets Importing");
|
|
SettingsInspector.addField("Edit Import Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
|
|
SettingsInspector.addSettingsField("Assets/AssetImporDefaultConfig", "Default Asset Import Config", "list", "", %formattedConfigList);
|
|
SettingsInspector.addSettingsField("Assets/AutoImport", "Automatically Import using default config", "bool", "If on, the asset importing process" @
|
|
"will attempt to automatically import any inbound assets"@
|
|
"using the default config, without prompting the import window."@
|
|
"The window will still display if any issues are detected", "");
|
|
SettingsInspector.addSettingsField("Assets/AutoImportLooseFiles", "Automatically Import Loose Files", "bool", "If on, will automatically import unassociated loose files in assets when navigating the Asset Browser.", "");
|
|
SettingsInspector.endGroup();
|
|
|
|
SettingsInspector.startGroup("Asset Browser");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showCoreModule", "Show Core Module in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showToolsModule", "Show Tools Module in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showOnlyPopulatedModule", "Show Only Modules with Assets in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showFolders", "Show Folders in Tiles view in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showEmptyFolders", "Show Empty Folders in Tiles view in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/showLooseFiles", "Show Loose Files when viewing in Asset Browser", "bool", "");
|
|
SettingsInspector.addSettingsField("AssetManagement/Assets/promptOnRename", "Prompt on Rename", "bool", "");
|
|
SettingsInspector.addSettingsField("Assets/Browser/doubleClickAction", "Double Click Action", "list", "Dictates what sort of action double clicking on an asset in the Browser will invoke", "Edit Asset,Spawn Asset");
|
|
SettingsInspector.addSettingsField("AssetManagement/Assets/closeBrowserOnDragAction", "Close Browser on Drag Action", "bool", "If on, the Asset Browser will automatically close after dragging an asset from it to the editor interface.");
|
|
SettingsInspector.endGroup();
|
|
}
|
|
//
|
|
//
|
|
//
|
|
|
|
function AssetBrowser::showVisibiltyOptions(%this)
|
|
{
|
|
BrowserVisibilityPopup.showPopup(Canvas);
|
|
}
|
|
|
|
function AssetBrowser::saveCurrentFiltersAsCollection(%this)
|
|
{
|
|
%colSetName = CreateNewCollectionSetCtrl-->collectionSetName.getText();
|
|
|
|
if(%colSetName $= "")
|
|
{
|
|
error("Collection Sets require a name!");
|
|
}
|
|
|
|
%collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
|
|
%collectionsCount += 1;
|
|
|
|
AssetBrowserCollectionSets.setValue("CollectionSetCount", %collectionsCount);
|
|
|
|
%collection = %colSetName TAB AssetBrowserSearchFilter.getText();
|
|
|
|
AssetBrowserCollectionSets.setValue("Collection"@%collectionsCount-1, %collection);
|
|
|
|
%success = AssetBrowserCollectionSets.write();
|
|
|
|
AssetBrowser.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::deleteCollectionSet(%this)
|
|
{
|
|
%collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
|
|
%tempCollectionListCount = 0;
|
|
|
|
%found = false;
|
|
for ( %i = 0; %i < %collectionsCount; %i++ )
|
|
{
|
|
%collection = AssetBrowserCollectionSets.value("Collection"@%i, "");
|
|
%collectionName = getField(%collection, 0);
|
|
%collectionTerm = getField(%collection, 1);
|
|
|
|
if(AssetBrowser.selectedCollectionSet !$= %collectionName)
|
|
{
|
|
%tempCollectionList[%tempCollectionListCount] = %collection;
|
|
%tempCollectionListCount++;
|
|
}
|
|
}
|
|
|
|
AssetBrowserCollectionSets.setValue("CollectionSetCount", %tempCollectionListCount);
|
|
for(%i=0; %i < %collectionsCount; %i++)
|
|
{
|
|
if(%i < %tempCollectionListCount)
|
|
AssetBrowserCollectionSets.setValue("Collection"@%i, %tempCollectionList[%i]);
|
|
else
|
|
AssetBrowserCollectionSets.remove("Collection"@%i);
|
|
}
|
|
|
|
AssetBrowserCollectionSets.write();
|
|
|
|
%this.loadDirectories();
|
|
}
|
|
|
|
function AssetBrowser::refreshPreviews(%this)
|
|
{
|
|
AssetBrowserFilterTree.onSelect(AssetBrowser.selectedItem);
|
|
}
|
|
|
|
function AssetBrowserFilterTree::onSelect(%this, %itemId)
|
|
{
|
|
if(%itemId == 1)
|
|
//can't select root
|
|
return;
|
|
|
|
%scrollCtrl = %this.getParent();
|
|
%scrollPos = %scrollCtrl.getScrollPosition();
|
|
|
|
//process special cases
|
|
%parentItem = %this.getParentItem(%itemId);
|
|
if(%parentItem == %this.tagsIdx)
|
|
{
|
|
//we selected a tag, so deal with that
|
|
AssetBrowser.setTagActive(%this.getItemText(%itemId));
|
|
}
|
|
else if(%parentItem == %this.collectionsIdx)
|
|
{
|
|
//A collection set was selected
|
|
AssetBrowser.setCollectionSetActive(%this.getItemValue(%itemId));
|
|
}
|
|
else if(%parentItem == %this.creatorIdx)
|
|
{
|
|
%name = %this.getItemText(%itemId);
|
|
AssetBrowser.dirHandler.currentAddress = "Creator/" @ %name;
|
|
AssetBrowser.rebuildAssetArray();
|
|
AssetBrowser.refresh();
|
|
}
|
|
else
|
|
{
|
|
//Make sure we have an actual module selected!
|
|
%parentId = %this.getParentItem(%itemId);
|
|
|
|
%name = %this.getItemText(%itemId);
|
|
|
|
%breadcrumbPath = %this.getItemValue(%itemId);
|
|
if(%breadcrumbPath !$= "")
|
|
%breadcrumbPath = %breadcrumbPath @ "/" @ %this.getItemText(%itemId);
|
|
else
|
|
%breadcrumbPath = %this.getItemText(%itemId);
|
|
|
|
if(%breadcrumbPath $= "")
|
|
%breadcrumbPath = AssetBrowser.dirHandler.currentAddress;
|
|
|
|
AssetBrowser.navigateTo(%breadcrumbPath);
|
|
}
|
|
|
|
//restore the scroll position
|
|
%scrollCtrl.schedule(1, "setScrollPosition", %scrollPos.x, %scrollPos.y);
|
|
}
|
|
|
|
function AssetBrowserFilterTree::hasAsParent(%this, %itemId, %text)
|
|
{
|
|
%parentId = %this.getParentItem(%itemId);
|
|
|
|
while(%parentId != 0)
|
|
{
|
|
%parentText = %this.getItemText(%parentId);
|
|
if(%parentText $= %text)
|
|
return true;
|
|
|
|
%parentId = %this.getParentItem(%parentId);
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
function AssetBrowser::rebuildAssetArray(%this)
|
|
{
|
|
if(!%this.previewArrayDirty)
|
|
{
|
|
%this.previewArrayDirty = true;
|
|
cancel(%this.pendingRebuild);
|
|
%this.pendingRebuild = %this.schedule(16, "doRebuildAssetArray");
|
|
}
|
|
}
|
|
|
|
function AssetBrowser::doRebuildAssetArray(%this)
|
|
{
|
|
if(!%this.previewArrayDirty)
|
|
return;
|
|
|
|
%breadcrumbPath = AssetBrowser.dirHandler.currentAddress;
|
|
|
|
// we have to empty out the list; so when we create new guicontrols, these dont linger
|
|
AssetBrowser-->assetList.deleteAllObjects();
|
|
AssetPreviewArray.empty();
|
|
|
|
if(isObject($AssetBrowser::AssetArray))
|
|
$AssetBrowser::AssetArray.delete();
|
|
|
|
$AssetBrowser::AssetArray = new ArrayObject();
|
|
|
|
//First, Query for our assets
|
|
%assetQuery = new AssetQuery();
|
|
%numAssetsFound = AssetDatabase.findAllAssets(%assetQuery);
|
|
|
|
%finalAssetCount = 0;
|
|
|
|
if(!startsWith(%breadcrumbPath, "Creator"))
|
|
{
|
|
//Add folders
|
|
if(EditorSettings.value("Assets/Browser/showFolders", true) == true)
|
|
{
|
|
%folders = getDirectoryList(%breadcrumbPath);
|
|
for(%f=0; %f < getFieldCount(%folders); %f++)
|
|
{
|
|
%folderName = getField(%folders, %f);
|
|
|
|
%searchActive = AssetSearchTerms.count() != 0;
|
|
if(%searchActive)
|
|
{
|
|
if(matchesSearch(%folderName, "Folder", ""))
|
|
{
|
|
$AssetBrowser::AssetArray.add( %breadcrumbPath, "FolderObjectType" TAB %folderName );
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//got it.
|
|
if(%folderName $= "shaderCache" || %folderName $= "cache" || %folderName $= ".git")
|
|
continue;
|
|
|
|
if(!%this.coreModulesFilter && %folderName $= "core" && %breadcrumbPath $= "")
|
|
continue;
|
|
|
|
if(!%this.toolsModulesFilter && %folderName $= "tools" && %breadcrumbPath $= "")
|
|
continue;
|
|
|
|
$AssetBrowser::AssetArray.add( %breadcrumbPath, "FolderObjectType" TAB %folderName );
|
|
}
|
|
}
|
|
}
|
|
|
|
//now, we'll iterate through, and find the assets that are in this module, and this category
|
|
for( %i=0; %i < %numAssetsFound; %i++)
|
|
{
|
|
%assetId = %assetQuery.getAsset(%i);
|
|
|
|
%assetPath = makeRelativePath(AssetDatabase.getAssetFilePath(%assetId));
|
|
%assetBasePath = filePath(%assetPath);
|
|
|
|
//clean up the path
|
|
%assetBasePath = strreplace(%assetBasePath, "//", "/");
|
|
|
|
%searchActive = AssetSearchTerms.count() != 0;
|
|
if(%assetBasePath $= %breadcrumbPath || (%searchActive && startsWith(%assetBasePath,%breadcrumbPath)))
|
|
{
|
|
//first, get the asset's module, as our major categories
|
|
%module = AssetDatabase.getAssetModule(%assetId);
|
|
%moduleName = %module.moduleId;
|
|
|
|
//it's good, so test that the category is right!
|
|
%assetType = AssetDatabase.getAssetCategory(%assetId);
|
|
if(%assetType $= "")
|
|
{
|
|
%assetType = AssetDatabase.getAssetType(%assetId);
|
|
}
|
|
|
|
//stop adding after previewsPerPage is hit
|
|
%assetName = AssetDatabase.getAssetName(%assetId);
|
|
|
|
if(%searchActive)
|
|
{
|
|
if(matchesSearch(%assetName, %assetType))
|
|
{
|
|
$AssetBrowser::AssetArray.add( %moduleName, %assetId);
|
|
|
|
if(%assetType !$= "Folder")
|
|
%finalAssetCount++;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(AssetBrowser.assetTypeFilter !$= "")
|
|
{
|
|
%filtersCount = getWordCount(AssetBrowser.assetTypeFilter);
|
|
for(%fltrIdx = 0; %fltrIdx < %filtersCount; %fltrIdx++)
|
|
{
|
|
%fltr = getWord(AssetBrowser.assetTypeFilter, %fltrIdx);
|
|
if(%fltr $= %assetType)
|
|
{
|
|
$AssetBrowser::AssetArray.add( %moduleName, %assetId );
|
|
|
|
if(%assetType !$= "FolderObjectType")
|
|
%finalAssetCount++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//got it.
|
|
$AssetBrowser::AssetArray.add( %moduleName, %assetId );
|
|
|
|
if(%assetType !$= "FolderObjectType")
|
|
%finalAssetCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!isObject(ABLooseFileArray))
|
|
new ArrayObject(ABLooseFileArray){};
|
|
|
|
%nonAssetFileCount = getNonAssetFilesInDir(%this.dirHandler.currentAddress, ABLooseFileArray);
|
|
|
|
%looseFiles = ABLooseFileArray.count();
|
|
for( %i=0; %i < %looseFiles; %i++)
|
|
{
|
|
%looseFileFullPath = ABLooseFileArray.getKey(%i);
|
|
%looseFilePath = filePath(%looseFileFullPath);
|
|
%looseFileName = fileName(%looseFileFullPath);
|
|
%looseFileExt = fileExt(%looseFileFullPath);
|
|
|
|
//iterate over the registered types to filter out types we special handle
|
|
for(%t=0; %t < ABAssetTypesList.count(); %t++)
|
|
{
|
|
%typeGroup = ABAssetTypesList.getKey(%t);
|
|
|
|
%typeEntryName = getField(ABAssetTypesList.getValue(%t), 0);
|
|
%filterDataList = getField(ABAssetTypesList.getValue(%t), 2);
|
|
|
|
if(%typeGroup $= "Asset")
|
|
{
|
|
%classNameCount = getTokenCount(%filterDataList, ";");
|
|
|
|
for(%e=0; %e < %classNameCount; %e++)
|
|
{
|
|
%className = getToken(%filterDataList, ";", %e);
|
|
|
|
if(%className $= %looseFileExt)
|
|
{
|
|
if(matchesSearch(%looseFileName, %typeEntryName))
|
|
$AssetBrowser::AssetArray.add( %looseFilePath, %typeEntryName TAB %looseFileName );
|
|
}
|
|
}
|
|
}
|
|
else if(%typeGroup $= "File")
|
|
{
|
|
%extensionsCount = getTokenCount(%filterDataList, ";");
|
|
|
|
for(%e=0; %e < %extensionsCount; %e++)
|
|
{
|
|
%extension = getToken(%filterDataList, ";", %e);
|
|
|
|
if(%extension $= %looseFileExt)
|
|
{
|
|
if(matchesSearch(%looseFileName, %typeEntryName))
|
|
$AssetBrowser::AssetArray.add( %looseFilePath, %typeEntryName TAB %looseFileName );
|
|
}
|
|
}
|
|
}
|
|
else if(%typeGroup $= "Object")
|
|
{
|
|
%classNameCount = getTokenCount(%filterDataList, ";");
|
|
|
|
//now we iterate over the root group to find any and all objects that match to class
|
|
for(%rgo = 0; %rgo < RootGroup.getCount(); %rgo++)
|
|
{
|
|
%rootGroupObj = RootGroup.getObject(%rgo);
|
|
%rootGroupObjPath = filePath(%rootGroupObj.getFileName());
|
|
if(%rootGroupObjPath !$= %this.dirHandler.currentAddress)
|
|
continue;
|
|
|
|
for(%c=0; %c < %classNameCount; %c++)
|
|
{
|
|
%className = getToken(%filterDataList, ";", %c);
|
|
|
|
if(%rootGroupObj.isMemberOfClass(%className))
|
|
{
|
|
if(matchesSearch(%className, %typeEntryName))
|
|
$AssetBrowser::AssetArray.add( %rootGroupObj, %typeEntryName TAB %className );
|
|
}
|
|
}
|
|
}
|
|
|
|
//check the datablocks group for certainty as well`
|
|
for(%rgo = 0; %rgo < DatablockGroup.getCount(); %rgo++)
|
|
{
|
|
%dbGroupObject = DatablockGroup.getObject(%rgo);
|
|
%dbGroupObjPath = filePath(%dbGroupObject.getFileName());
|
|
if(%dbGroupObjPath !$= %this.dirHandler.currentAddress)
|
|
continue;
|
|
|
|
for(%c=0; %c < %classNameCount; %c++)
|
|
{
|
|
%className = getToken(%filterDataList, ";", %c);
|
|
|
|
if(%dbGroupObject.isMemberOfClass(%className))
|
|
{
|
|
if(matchesSearch(%className, %typeEntryName))
|
|
$AssetBrowser::AssetArray.add( %dbGroupObject, %typeEntryName TAB %className );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else //If we've selected into the Creator section, we have special handling for that
|
|
{
|
|
//One of the creator folders was selected
|
|
%creatorGroup = AssetBrowserFilterTree.getItemText(AssetBrowserFilterTree.getSelectedItem(0));
|
|
|
|
if(%creatorGroup $= "Creator")
|
|
{
|
|
//add folders for the groups
|
|
%placeholderVar = "";
|
|
}
|
|
else
|
|
{
|
|
for ( %i = 0; %i < %this.creatorClassArray.count(); %i++ )
|
|
{
|
|
%group = %this.creatorClassArray.getKey( %i );
|
|
|
|
//Do some filter logic do skip out of groups if we're in the wrong editor mode for it
|
|
%creatorEditorFilter = "WorldEditor";
|
|
if(GuiEditorIsActive())
|
|
{
|
|
%creatorEditorFilter = "GuiEditor";
|
|
}
|
|
|
|
%creatorGroupIndex = AssetBrowserCreatorGroupsList.getIndexFromValue(%group);
|
|
%creatorGroupKey = AssetBrowserCreatorGroupsList.getKey(%creatorGroupIndex);
|
|
|
|
if ( %group $= %creatorGroup && %creatorGroupKey $= %creatorEditorFilter )
|
|
{
|
|
%creatorObj = %this.creatorClassArray.getValue( %i );
|
|
%class = %creatorObj.val[0];
|
|
%name = %creatorObj.val[1];
|
|
%func = %creatorObj.val[2];
|
|
|
|
%searchActive = AssetSearchTerms.count() != 0;
|
|
if(%searchActive && !matchesSearch(%name, "Creator"))
|
|
continue;
|
|
|
|
$AssetBrowser::AssetArray.add( %name, "Creator" TAB %creatorObj );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for(%i=0; %i < $AssetBrowser::AssetArray.count(); %i++)
|
|
%this.buildAssetPreview( $AssetBrowser::AssetArray.getValue(%i), $AssetBrowser::AssetArray.getKey(%i) );
|
|
|
|
//Queue population of any non-Type Card preview images
|
|
%this.schedule(32, "populatePreviewImages");
|
|
|
|
AssetBrowser_FooterText.text = %finalAssetCount @ " Assets";
|
|
|
|
%activeTypeFilterList = "";
|
|
if(AssetBrowser.assetTypeFilter $= "")
|
|
{
|
|
if(!AssetTypeListPopup.isItemChecked(0))
|
|
{
|
|
for(%f=0; %f < ABAssetTypesList.Count(); %f++)
|
|
{
|
|
%isChecked = AssetTypeListPopup.isItemChecked(%f+2);
|
|
|
|
if(%isChecked)
|
|
{
|
|
%filterTypeData = ABAssetTypesList.getKey(%f);
|
|
%filterTypeName = getField(%filterTypeData, 0);
|
|
|
|
if(%activeTypeFilterList $= "")
|
|
%activeTypeFilterList = %filterTypeName;
|
|
else
|
|
%activeTypeFilterList = %activeTypeFilterList @ ", " @ %filterTypeName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
%activeTypeFilterList = AssetBrowser.assetTypeFilter;
|
|
}
|
|
|
|
if(%activeTypeFilterList !$= "")
|
|
AssetBrowser_FooterText.text = AssetBrowser_FooterText.text @ " | Active Type Filters: " @ %activeTypeFilterList;
|
|
|
|
%this.previewArrayDirty = false;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Search
|
|
function AssetBrowser::updateSearchTextFromFilter(%this)
|
|
{
|
|
AssetSearchTerms.sortk();
|
|
|
|
//Update the displayed search text!
|
|
%newSearchPhrase = "";
|
|
%currentAction = "";
|
|
%actionCount = 0;
|
|
for(%i=0; %i < AssetSearchTerms.count(); %i++)
|
|
{
|
|
%action = AssetSearchTerms.getKey(%i);
|
|
%word = AssetSearchTerms.getValue(%i);
|
|
|
|
if(%action !$= %currentAction)
|
|
{
|
|
if(%actionCount != 0)
|
|
{
|
|
if(%action !$= "")
|
|
%newSearchPhrase = %newSearchPhrase @ ";" @ %action @ ":" @ %word;
|
|
else
|
|
%newSearchPhrase = %newSearchPhrase @ ";" @ %word;
|
|
}
|
|
else
|
|
{
|
|
if(%action !$= "")
|
|
%newSearchPhrase = %action @ ":" @ %word;
|
|
else
|
|
%newSearchPhrase = %word;
|
|
}
|
|
|
|
%actionCount++;
|
|
}
|
|
else
|
|
{
|
|
%newSearchPhrase = %newSearchPhrase @ "," @ %word;
|
|
}
|
|
|
|
%currentAction = %action;
|
|
}
|
|
|
|
AssetBrowserSearchFilter.setText(%newSearchPhrase);
|
|
}
|
|
|
|
function AssetBrowser::processSearchFilter(%this)
|
|
{
|
|
AssetSearchTerms.empty();
|
|
|
|
%searchText = AssetBrowserSearchFilter.getText();
|
|
|
|
%termCount = getTokenCount(%searchText, ";");
|
|
for(%s=0; %s < %termCount; %s++)
|
|
{
|
|
%term = getToken(%searchText, ";", %s);
|
|
|
|
%phraseCount = getTokenCount(%term, ":");
|
|
|
|
if(%phraseCount == 2)
|
|
{
|
|
//action/words split
|
|
%action = getToken(%term, ":", 0);
|
|
%words = getToken(%term, ":", 1);
|
|
}
|
|
else
|
|
{
|
|
%action = "";
|
|
%words = getToken(%term, ":", 0);
|
|
}
|
|
|
|
%wordCount = getTokenCount(%words, ",");
|
|
for(%w=0; %w < %wordCount; %w++)
|
|
{
|
|
%word = getToken(%words, ",", %w);
|
|
AssetSearchTerms.add(%action, %word);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Takes an item and compares it against the parsed search language
|
|
//This is written to be inclusive, rather than exclusive
|
|
function matchesSearch(%assetName, %assetType)
|
|
{
|
|
if(AssetSearchTerms.count() == 0)
|
|
return true;
|
|
|
|
%matchTags = false;
|
|
%matchType = false;
|
|
%matchName = false;
|
|
|
|
%needsTag = false;
|
|
%needsType = false;
|
|
%needsName = false;
|
|
for(%i=0; %i < AssetSearchTerms.count(); %i++)
|
|
{
|
|
%action = AssetSearchTerms.getKey(%i);
|
|
%word = AssetSearchTerms.getValue(%i);
|
|
|
|
if(%action $= "tag" && %matchTags == false)
|
|
{
|
|
%needsTag = true;
|
|
if(%assetType $= "Datablock")
|
|
{
|
|
if(%assetName.category $= %word)
|
|
%matchTags = true;
|
|
}
|
|
else
|
|
{
|
|
if(strstr(strlwr(%assetName.tags), strlwr(%word)) != -1)
|
|
%matchTags = true;
|
|
}
|
|
}
|
|
else if(%action $= "type" && %matchType == false)
|
|
{
|
|
%needsType = true;
|
|
if(%assetType $= %word)
|
|
%matchType = true;
|
|
}
|
|
else if(%action $= "" && %matchName == false)
|
|
{
|
|
%needsName = true;
|
|
if(strstr(strlwr(%assetName), strlwr(%word)) != -1)
|
|
%matchName = true;
|
|
}
|
|
}
|
|
|
|
if(((%needsTag && %matchTags) || !%needsTag) &&
|
|
((%needsType && %matchType) || !%needsType) &&
|
|
((%needsName && %matchName) || !%needsName))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Search Filters
|
|
function AssetBrowserSearchFilterTxt::onWake( %this )
|
|
{
|
|
/*%filter = %this.treeView.getFilterText();
|
|
if( %filter $= "" )
|
|
%this.setText( "\c2Filter..." );
|
|
else
|
|
%this.setText( %filter );*/
|
|
}
|
|
|
|
function AssetBrowserSearchFilterTxt::onGainFirstResponder( %this )
|
|
{
|
|
%this.selectAllText();
|
|
}
|
|
|
|
// When Enter is pressed in the filter text control, pass along the text of the control
|
|
// as the treeview's filter.
|
|
function AssetBrowserFolderSearchFilter::onReturn( %this )
|
|
{
|
|
%text = %this.getText();
|
|
if( %text $= "" )
|
|
%this.reset();
|
|
|
|
AssetBrowser.refresh();
|
|
}
|
|
|
|
function AssetBrowserFolderSearchFilter::onEdited(%this)
|
|
{
|
|
if(AssetBrowserFolderSearchFilter.getText() $= "")
|
|
{
|
|
AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
|
|
}
|
|
else
|
|
{
|
|
AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/cross.png");
|
|
}
|
|
}
|
|
|
|
function AssetBrowserSearchFilter::onEdited(%this)
|
|
{
|
|
AssetBrowserSearchFilter.updateButton();
|
|
}
|
|
|
|
function AssetBrowserSearchFilter::onReturn( %this )
|
|
{
|
|
%text = %this.getText();
|
|
if( %text $= "" )
|
|
%this.reset();
|
|
|
|
AssetBrowserSearchFilter.updateButton();
|
|
|
|
AssetBrowser.processSearchFilter();
|
|
|
|
AssetBrowser.rebuildAssetArray();
|
|
}
|
|
|
|
function AssetBrowserSearchFilter::updateButton(%this)
|
|
{
|
|
if(%this.getText() $= "")
|
|
{
|
|
AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
|
|
}
|
|
else
|
|
{
|
|
AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/cross.png");
|
|
}
|
|
}
|
|
|
|
function AssetBrowserFolderSearchFilter::reset( %this )
|
|
{
|
|
%this.setText( "" );
|
|
AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
|
|
//AssetBrowser.refresh();
|
|
}
|
|
|
|
function AssetBrowserSearchFilter::reset( %this )
|
|
{
|
|
%this.setText( "" );
|
|
AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
|
|
//AssetBrowser.rebuildAssetArray();
|
|
}
|
|
|
|
function AssetBrowserFolderSearchBtn::onClick( %this )
|
|
{
|
|
AssetBrowserFolderSearchFilter.reset();
|
|
AssetBrowser.refresh();
|
|
}
|
|
|
|
function AssetBrowserAssetSearchBtn::onClick( %this )
|
|
{
|
|
AssetBrowserSearchFilter.reset();
|
|
AssetBrowser.processSearchFilter();
|
|
|
|
AssetBrowser.rebuildAssetArray();
|
|
}
|
|
|
|
//
|
|
//
|
|
// Navigation
|
|
function AssetBrowser::navigateTo(%this, %address, %historyNav)
|
|
{
|
|
//Sanitize
|
|
if(startsWith(%address, "/"))
|
|
%address = strreplace(%address, "/", "");
|
|
|
|
//Don't bother navigating if it's to the place we already are
|
|
if(%this.dirHandler.currentAddress !$= %address)
|
|
{
|
|
%this.dirHandler.navigateTo(%address, %historyNav);
|
|
|
|
//%this.updateNavigationBreadcrumb(%address);
|
|
|
|
%this.lastValidNavPath = %address;
|
|
%this-->navPath.setText(%address);
|
|
|
|
%module = %this.dirHandler.getModuleFromAddress(%address);
|
|
if(%module !$= "")
|
|
{
|
|
//legit module, so set it as current target
|
|
%this.SelectedModule = %module.moduleId;
|
|
}
|
|
|
|
if(%this.hasLooseFilesInDir())
|
|
{
|
|
if(EditorSettings.value("Assets/AutoImportLooseFiles", false) && EditorSettings.value("Assets/AutoImport", false))
|
|
{
|
|
AssetBrowser.autoImportSimpleLooseFiles();
|
|
}
|
|
else
|
|
{
|
|
%this-->AutoImportAssetButton.visible = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
%this-->AutoImportAssetButton.visible = false;
|
|
}
|
|
}
|
|
|
|
%this.rebuildAssetArray();
|
|
%this.refresh();
|
|
}
|
|
|
|
function AssetBrowser::navigateHistoryForward(%this)
|
|
{
|
|
%this.dirHandler.navigateHistoryForward();
|
|
|
|
%this.updateNavigationBreadcrumb();
|
|
|
|
%address = %this.dirHandler.currentAddress;
|
|
|
|
%module = AssetBrowser.dirHandler.getModuleFromAddress(%address);
|
|
if(%module !$= "")
|
|
{
|
|
//legit module, so set it as current target
|
|
%this.SelectedModule = %module.moduleId;
|
|
}
|
|
|
|
%this.lastValidNavPath = %address;
|
|
%this-->navPath.setText(%address);
|
|
|
|
%this.rebuildAssetArray();
|
|
}
|
|
|
|
function AssetBrowser::navigateHistoryBack(%this)
|
|
{
|
|
%this.dirHandler.navigateHistoryBack();
|
|
|
|
%this.updateNavigationBreadcrumb();
|
|
|
|
%address = %this.dirHandler.currentAddress;
|
|
|
|
%module = %this.dirHandler.getModuleFromAddress(%address);
|
|
if(%module !$= "")
|
|
{
|
|
//legit module, so set it as current target
|
|
%this.SelectedModule = %module.moduleId;
|
|
}
|
|
|
|
%this.lastValidNavPath = %address;
|
|
%this-->navPath.setText(%address);
|
|
|
|
%this.rebuildAssetArray();
|
|
}
|
|
|
|
function AssetBrowser::updateNavigationBreadcrumb(%this, %address)
|
|
{
|
|
//clear the breadcrumb bar
|
|
AssetBrowser_BreadcrumbBar.clear();
|
|
|
|
//break down the address
|
|
%folderCount = getTokenCount(%address, "/");
|
|
|
|
%rebuiltPath = "";
|
|
for(%f=0; %f < %folderCount; %f++)
|
|
{
|
|
%folderName = getToken(%address, "/", %f);
|
|
|
|
%rebuiltPath = %f == 0 ? %folderName : %rebuiltPath @ "/" @ %folderName;
|
|
|
|
%folderNavButton = new GuiButtonCtrl()
|
|
{
|
|
profile = ToolsGuiButtonProfile;
|
|
text = %folderName;
|
|
command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
|
|
extent = "100" SPC AssetBrowser_BreadcrumbBar.extent.y;
|
|
};
|
|
|
|
AssetBrowser_BreadcrumbBar.add(%folderNavButton);
|
|
|
|
if(%f != %folderCount-1)
|
|
{
|
|
%folderSpacerButton = new GuiBitmapButtonCtrl()
|
|
{
|
|
profile = ToolsGuiButtonProfile;
|
|
bitmapAsset = "ToolsModule:rightArrowWhite_image";
|
|
bitmapMode = "Centered";
|
|
extent = "25" SPC AssetBrowser_BreadcrumbBar.extent.y;
|
|
//command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
|
|
};
|
|
|
|
AssetBrowser_BreadcrumbBar.add(%folderSpacerButton);
|
|
}
|
|
}
|
|
|
|
//refresh the nav buttons to display the history
|
|
%backButtonHistory = "";
|
|
for(%i=0; %i < AssetBrowser.dirHandler.prevHistoryList.Count(); %i++)
|
|
{
|
|
%prevAddress = AssetBrowser.dirHandler.prevHistoryList.getKey(%i);
|
|
%backButtonHistory = %i==0 ? %prevAddress @ "\n" : %backButtonHistory @ %prevAddress @ "\n";
|
|
}
|
|
|
|
AssetBrowser_NavigateBackBtn.tooltip = %backButtonHistory;
|
|
|
|
%foreButtonHistory = "";
|
|
for(%i=0; %i < AssetBrowser.dirHandler.foreHistoryList.Count(); %i++)
|
|
{
|
|
%prevAddress = AssetBrowser.dirHandler.foreHistoryList.getKey(%i);
|
|
%foreButtonHistory = %i==0 ? %prevAddress @ "\n" : %foreButtonHistory @ %prevAddress @ "\n";
|
|
}
|
|
|
|
AssetBrowser_NavigateForwardBtn.tooltip = %foreButtonHistory;
|
|
}
|
|
|
|
function assetBrowserNavPath::onReturn(%this)
|
|
{
|
|
%newPath = %this.getText();
|
|
if(isDirectory(%newPath))
|
|
{
|
|
AssetBrowser.lastValidNavPath = %newPath;
|
|
AssetBrowser.navigateTo(%newPath);
|
|
}
|
|
else
|
|
{
|
|
%this.setText(AssetBrowser.lastValidNavPath);
|
|
AssetBrowser.navigateTo(AssetBrowser.lastValidNavPath);
|
|
}
|
|
}
|
|
//
|
|
//
|
|
//
|
|
function AssetBrowser::reloadModules(%this)
|
|
{
|
|
ModuleDatabase.unloadGroup("Game");
|
|
|
|
%modulesList = ModuleDatabase.findModules();
|
|
|
|
%count = getWordCount(%modulesList);
|
|
|
|
for(%i=0; %i < %count; %i++)
|
|
{
|
|
%moduleId = getWord(%modulesList, %i).ModuleId;
|
|
ModuleDatabase.unloadExplicit(%moduleId);
|
|
}
|
|
|
|
ModuleDatabase.scanModules();
|
|
|
|
%modulesList = ModuleDatabase.findModules();
|
|
|
|
%count = getWordCount(%modulesList);
|
|
|
|
for(%i=0; %i < %count; %i++)
|
|
{
|
|
%moduleId = getWord(%modulesList, %i).ModuleId;
|
|
ModuleDatabase.loadExplicit(%moduleId);
|
|
}
|
|
|
|
//ModuleDatabase.loadGroup("Game");
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
function AssetBrowser::toggleFolderCollapseButton(%this)
|
|
{
|
|
%this.folderPanelState = !%this.folderPanelState;
|
|
|
|
//If we're collapsing
|
|
if(!%this.folderPanelState)
|
|
{
|
|
//Store the original
|
|
%this.folderPanelSplit = AssetBrowser_MainSplit.splitPoint.x;
|
|
|
|
//collapse it
|
|
AssetBrowser_MainSplit.setSplitPoint(AssetBrowser_MainSplit.splitterSize SPC AssetBrowser_MainSplit.splitPoint.y);
|
|
}
|
|
else
|
|
{
|
|
//restore the original
|
|
AssetBrowser_MainSplit.setSplitPoint(%this.folderPanelSplit SPC AssetBrowser_MainSplit.splitPoint.y);
|
|
}
|
|
}
|
|
//
|
|
//
|
|
// Drag n drop
|
|
function AssetBrowserPreviewButton::onMouseDragged(%this)
|
|
{
|
|
%payload = %this.clone();
|
|
%payload.position = "0 0";
|
|
//%payload.class = "AssetPreviewControl";
|
|
|
|
%xOffset = getWord( %payload.extent, 0 ) / 2;
|
|
%yOffset = getWord( %payload.extent, 1 ) / 2;
|
|
|
|
// Compute the initial position of the GuiDragAndDrop control on the cavas based on the current
|
|
// mouse cursor position.
|
|
|
|
%cursorpos = Canvas.getCursorPos();
|
|
%xPos = getWord( %cursorpos, 0 ) - %xOffset;
|
|
%yPos = getWord( %cursorpos, 1 ) - %yOffset;
|
|
|
|
if(!isObject(EditorDragAndDropLayer))
|
|
{
|
|
new GuiControl(EditorDragAndDropLayer)
|
|
{
|
|
position = "0 0";
|
|
extent = Canvas.extent;
|
|
};
|
|
}
|
|
|
|
// Create the drag control.
|
|
%ctrl = new GuiDragAndDropControl()
|
|
{
|
|
canSaveDynamicFields = "0";
|
|
Profile = "ToolsGuiSolidDefaultProfile";
|
|
HorizSizing = "right";
|
|
VertSizing = "bottom";
|
|
Position = %xPos SPC %yPos;
|
|
extent = %payload.extent;
|
|
MinExtent = "4 4";
|
|
canSave = "1";
|
|
Visible = "1";
|
|
hovertime = "1000";
|
|
|
|
// Let the GuiDragAndDropControl delete itself on mouse-up. When the drag is aborted,
|
|
// this not only deletes the drag control but also our payload.
|
|
deleteOnMouseUp = true;
|
|
|
|
useWholeCanvas = true;
|
|
|
|
// To differentiate drags, use the namespace hierarchy to classify them.
|
|
// This will allow a color swatch drag to tell itself apart from a file drag, for example.
|
|
class = "AssetPreviewControlType_AssetDrop";
|
|
};
|
|
|
|
// Add the temporary color swatch to the drag control as the payload.
|
|
%ctrl.add( %payload );
|
|
|
|
// Start drag by adding the drag control to the canvas and then calling startDragging().
|
|
//Canvas.getContent().add( %ctrl );
|
|
EditorDragAndDropLayer.add(%ctrl);
|
|
Canvas.pushDialog(EditorDragAndDropLayer);
|
|
|
|
%ctrl.startDragging( %xOffset, %yOffset );
|
|
|
|
Canvas.repaint();
|
|
}
|
|
|
|
function AssetBrowserPreviewButton::onControlDragCancelled(%this)
|
|
{
|
|
Canvas.popDialog(EditorDragAndDropLayer);
|
|
}
|
|
|
|
function AssetBrowserPreviewButton::onControlDropped( %this, %payload, %position )
|
|
{
|
|
Canvas.popDialog(EditorDragAndDropLayer);
|
|
|
|
if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
|
|
return;
|
|
|
|
// If dropped on same button whence we came from,
|
|
// do nothing.
|
|
|
|
if( %payload.dragSourceControl == %this )
|
|
return;
|
|
|
|
%assetType = %payload.assetType;
|
|
%assetName = %payload.assetName;
|
|
%moduleName = %payload.moduleName;
|
|
|
|
%targetAssetName = %this.assetName;
|
|
%targetAssetType = %this.assetType;
|
|
%targetModuleName = %this.moduleName;
|
|
|
|
if( %payload.dragSourceControl.class $= "AssetPreviewButton" && %targetAssetType $= "Folder")
|
|
{
|
|
%destination = %targetModuleName @ "/" @ %targetAssetName;
|
|
|
|
if(%assetType $= "Folder")
|
|
{
|
|
%originFolder = %moduleName @ "/" @ %assetName;
|
|
%destination = %destination @ "/" @ %assetName;
|
|
|
|
//Do any cleanup required given the type
|
|
if(AssetBrowser.isMethod("moveFolder"))
|
|
eval(AssetBrowser @ ".moveFolder(\""@%originFolder@"\",\""@%destination@"\");");
|
|
}
|
|
else
|
|
{
|
|
%assetId = %moduleName @ ":" @ %assetName;
|
|
%assetDef = AssetDatabase.acquireAsset(%assetId);
|
|
%assetType = AssetDatabase.getAssetType(%assetId);
|
|
|
|
//Do any cleanup required given the type
|
|
if(AssetBrowser.isMethod("move"@%assetType))
|
|
{
|
|
%command = AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %destination @ "\");";
|
|
eval(AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %destination @ "\");");
|
|
}
|
|
}
|
|
|
|
AssetBrowser.refresh();
|
|
}
|
|
}
|
|
|
|
function EWorldEditor::onControlDropped( %this, %payload, %position )
|
|
{
|
|
Canvas.popDialog(EditorDragAndDropLayer);
|
|
|
|
// Make sure this is a color swatch drag operation.
|
|
if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
|
|
return;
|
|
|
|
// If dropped on same button whence we came from,
|
|
// do nothing.
|
|
|
|
if( %payload.dragSourceControl == %this )
|
|
return;
|
|
|
|
%assetType = %payload.assetType;
|
|
|
|
%createPosition = ObjectCreator.getCreateObjectPosition(); //LocalClientConnection.camera.position;
|
|
%targetPosition = EWorldEditor.unproject(%createPosition SPC 1);
|
|
%camPos = LocalClientConnection.camera.getPosition();
|
|
%rayResult = containerRayCast(%camPos, %targetPosition, -1);
|
|
|
|
%pos = ObjectCreator.getCreateObjectPosition();
|
|
|
|
if(%rayResult != 0)
|
|
{
|
|
%pos = getWords(%rayResult, 1, 3);
|
|
}
|
|
else
|
|
{
|
|
%pos = "0 0 0";
|
|
}
|
|
|
|
AssetBrowser.callAssetTypeFunc(%assetType, "onWorldEditorDropped", %payload.moduleName, %payload.assetName, %pos);
|
|
|
|
if(EditorSettings.value("AssetManagement/Assets/closeBrowserOnDragAction", false))
|
|
{
|
|
AssetBrowser.hideDialog();
|
|
}
|
|
|
|
EWorldEditor.isDirty = true;
|
|
}
|
|
|
|
function GuiEditor::onControlDropped(%this, %payload, %position)
|
|
{
|
|
Canvas.popDialog(EditorDragAndDropLayer);
|
|
// Make sure we have the right kind of D&D.
|
|
|
|
if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) &&
|
|
!%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ))
|
|
return;
|
|
|
|
if( %payload.dragSourceControl == %this )
|
|
return;
|
|
|
|
%pos = %payload.getGlobalPosition();
|
|
%x = getWord(%pos, 0);
|
|
%y = getWord(%pos, 1);
|
|
|
|
if(%payload.assetType !$= "Creator")
|
|
{
|
|
//dealing with an actual asset, so build the assetName
|
|
%assetId = %payload.moduleName @ ":" @ %payload.assetName;
|
|
%assetType = AssetDatabase.getAssetType(%assetId);
|
|
|
|
AssetBrowser.callAssetTypeFunc(%assetType, "GUIEditorDropped", %payload.moduleName, %payload.assetName, %pos);
|
|
}
|
|
else
|
|
{
|
|
%className = %payload.assetName;
|
|
if(%payload.altCommand !$= "")
|
|
{
|
|
%cmd = %payload.altCommand;
|
|
}
|
|
else
|
|
{
|
|
%cmd = "return new " @ %className @ "();";
|
|
}
|
|
%ctrl = eval( %cmd );
|
|
}
|
|
|
|
%this.addNewCtrl(%ctrl);
|
|
|
|
%ctrl.setPositionGlobal(%x, %y);
|
|
%this.setFirstResponder();
|
|
|
|
if(EditorSettings.value("AssetManagement/Assets/closeBrowserOnDragAction", false))
|
|
{
|
|
AssetBrowser.hideDialog();
|
|
}
|
|
}
|
|
|
|
function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
|
|
{
|
|
Canvas.popDialog(EditorDragAndDropLayer);
|
|
|
|
if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
|
|
return;
|
|
|
|
%assetType = %payload.assetType;
|
|
%assetName = %payload.assetName;
|
|
%moduleName = %payload.moduleName;
|
|
|
|
%item = %this.getItemAtPosition(%position);
|
|
|
|
%parent = %this.getParentItem(%item);
|
|
|
|
if(%item != 1)
|
|
{
|
|
//we're a folder entry, cool
|
|
%path = %this.getItemValue(%item) @ "/" @ %this.getItemText(%item);
|
|
|
|
if(%path !$= AssetBrowser.dirHandler.CurrentAddress)
|
|
{
|
|
if(getModuleFromAddress(%path) !$= getModuleFromAddress(AssetBrowser.dirHandler.CurrentAddress))
|
|
{
|
|
AssetBrowser.callAssetTypeFunc(%this.assetType, "onMoveModule", %this.moduleName, %this.assetName, %path);
|
|
}
|
|
else
|
|
{
|
|
AssetBrowser.callAssetTypeFunc(%this.assetType, "onMovePath", %this.moduleName, %this.assetName, %path);
|
|
}
|
|
|
|
//we're trying to move the asset to a different module!
|
|
//toolsMessageBoxYesNo( "Move Asset", "Do you wish to move asset " @ %assetName @ " to " @ %path @ "?",
|
|
// "AssetBrowser.moveAsset(\""@ %moduleName @ ":" @ %assetName @"\", \""@%path@"\");", "");
|
|
}
|
|
}
|
|
}
|
|
|
|
function AssetBrowserFilterTree::onDragDropped( %this )
|
|
{
|
|
}
|
|
|
|
function AssetBrowser::hasLooseFilesInDir(%this)
|
|
{
|
|
if(!isDirectory(%this.dirHandler.currentAddress))
|
|
return false;
|
|
|
|
//First, wipe out any files inside the folder first
|
|
%file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
|
|
|
|
%aq = new AssetQuery();
|
|
|
|
while( %file !$= "" )
|
|
{
|
|
if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
|
|
{
|
|
%assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
|
|
|
|
if(%assetsFound == 0)
|
|
{
|
|
%ext = fileExt(%file);
|
|
if(isShapeFormat(%ext) || isImageFormat(%ext) || isSoundFormat(%ext))
|
|
{
|
|
%aq.delete();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
%file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
|
|
}
|
|
|
|
%aq.delete();
|
|
return false;
|
|
}
|
|
|
|
function AssetBrowser::autoImportSimpleLooseFiles(%this)
|
|
{
|
|
%importer = new AssetImporter();
|
|
|
|
//First, wipe out any files inside the folder first
|
|
%file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
|
|
|
|
%aq = new AssetQuery();
|
|
|
|
while( %file !$= "" )
|
|
{
|
|
if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file)
|
|
&& !strIsMatchExpr("*.cs", %file) && !strIsMatchExpr("*.tscript", %file) && !strIsMatchExpr("*.module", %file))
|
|
{
|
|
%aq.clear();
|
|
%assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
|
|
|
|
if(%assetsFound == 0)
|
|
{
|
|
%ext = fileExt(%file);
|
|
if(isShapeFormat(%ext) || isImageFormat(%ext) || isSoundFormat(%ext))
|
|
{
|
|
%assetId = %importer.autoImportFile(%file);
|
|
}
|
|
}
|
|
}
|
|
|
|
%file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
|
|
}
|
|
|
|
%aq.delete();
|
|
%importer.delete();
|
|
|
|
%this.refresh();
|
|
}
|
|
|
|
function AssetBrowser::getLooseFilesInDir(%this)
|
|
{
|
|
if(!isObject(ABLooseFileArray))
|
|
new ArrayObject(ABLooseFileArray);
|
|
|
|
ABLooseFileArray.empty();
|
|
|
|
%showLooseFiles = EditorSettings.value("Assets/Browser/showLooseFiles", false);
|
|
if(%showLooseFiles == false)
|
|
return;
|
|
|
|
//First, wipe out any files inside the folder first
|
|
%file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
|
|
|
|
%aq = new AssetQuery();
|
|
|
|
while( %file !$= "" )
|
|
{
|
|
if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
|
|
{
|
|
%assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
|
|
|
|
if(%assetsFound == 0)
|
|
{
|
|
ABLooseFileArray.add(%file);
|
|
}
|
|
}
|
|
|
|
%file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
|
|
}
|
|
|
|
%aq.delete();
|
|
return false;
|
|
}
|
|
|
|
function getNonAssetFilesInDir(%path, %arrayObj)
|
|
{
|
|
//echo("getNonAssetFilesInDir() - path: " @ %path);
|
|
|
|
if(!isObject(%arrayObj))
|
|
{
|
|
error("getNonAssetFilesInDir() - requires a valid arrayObject to place found non-Asset files into!");
|
|
return 0;
|
|
}
|
|
|
|
%arrayObj.empty();
|
|
|
|
//First, wipe out any files inside the folder first
|
|
%file = findFirstFileMultiExpr( %path @ "/*.*", false);
|
|
|
|
%aq = new AssetQuery();
|
|
|
|
while( %file !$= "" )
|
|
{
|
|
if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
|
|
{
|
|
%assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
|
|
|
|
if(%assetsFound == 0)
|
|
{
|
|
%arrayObj.add(%file);
|
|
}
|
|
}
|
|
|
|
%file = findNextFileMultiExpr( %path @ "/*.*" );
|
|
}
|
|
|
|
%aq.delete();
|
|
|
|
return %arrayObj.count();
|
|
}
|
|
|
|
//
|
|
//
|
|
function AssetBrowser::importLooseFiles(%this)
|
|
{
|
|
echo("Adding loose files at directory " @ %this.dirHandler.currentAddress);
|
|
LooseFileAuditWindow.showDialog(%this.dirHandler.currentAddress);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function getAssetPreviewImage(%asset)
|
|
{
|
|
if(isFile(%asset))
|
|
{
|
|
%aq = new AssetQuery();
|
|
%assetsFound = AssetDatabase.findAssetLooseFile(%aq, %asset);
|
|
if(%assetsFound != 0)
|
|
{
|
|
%asset = %aq.getAsset(0);
|
|
}
|
|
else
|
|
{
|
|
%previewPath = %asset;
|
|
}
|
|
|
|
%aq.delete();
|
|
}
|
|
|
|
if(AssetDatabase.isDeclaredAsset(%asset))
|
|
{
|
|
%moduleName = AssetDatabase.getAssetModule(%asset).ModuleId;
|
|
%assetName = AssetDatabase.getAssetName(%asset);
|
|
%previewAssetName = "ToolsModule:" @ %moduleName @ "_" @ %assetName @ "_PreviewImage";
|
|
|
|
if(AssetDatabase.isDeclaredAsset(%previewAssetName))
|
|
{
|
|
%previewDef = AssetDatabase.acquireAsset(%previewAssetName);
|
|
%previewPath = %previewDef.getImagePath();
|
|
AssetDatabase.releaseAsset(%previewAssetName);
|
|
}
|
|
else
|
|
{
|
|
%previewPath = %asset;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
%previewPath = %asset;
|
|
}
|
|
|
|
if(%previewPath $= "")
|
|
%previewPath = "ToolsModule:unknownImage_image";
|
|
|
|
return %previewPath;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function AssetBrowserWindow::dockPanel(%this)
|
|
{
|
|
if(%this.docked == true)
|
|
return;
|
|
|
|
%this.resizing = true;
|
|
|
|
%this.docked = true;
|
|
|
|
%this.canCollapse = "0";
|
|
%this.canMove = "0";
|
|
%this.resizeWidth = "0";
|
|
|
|
AssetBrowserWindow_UnDockBtn.Visible = "1";
|
|
AssetBrowserWindow_DockBtn.Visible = "0";
|
|
|
|
EditorGui.updateSideBar();
|
|
}
|
|
|
|
function AssetBrowserWindow::releasePanel(%this)
|
|
{
|
|
if(%this.docked == false)
|
|
return;
|
|
|
|
%this.canCollapse = "1";
|
|
%this.canMove = "1";
|
|
%this.resizeWidth = "1";
|
|
|
|
AssetBrowserWindow_UnDockBtn.Visible = "0";
|
|
AssetBrowserWindow_DockBtn.Visible = "1";
|
|
|
|
// Let's do a small resize so it's visually clear we're "undocking"
|
|
%position = %this.position.x + 6 SPC %this.position.y - 6;
|
|
%extent = %this.extent.x SPC %this.extent.y;
|
|
%this.resize(%position.x, %position.y, %extent.x, %extent.y);
|
|
|
|
%this.docked = false;
|
|
%this.resizing = false;
|
|
|
|
EditorGui.updateSideBar();
|
|
}
|
|
|
|
function AssetBrowserWindow::onResize(%this, %posX, %posY, %width, %height)
|
|
{
|
|
if (%width>%height)
|
|
AssetBrowser-->assetList.fillRowFirst = true;
|
|
else
|
|
AssetBrowser-->assetList.fillRowFirst = false;
|
|
AssetBrowser.rebuildAssetArray();
|
|
} |