private static void UpgradeAllTextObjects()
{
if (
!EditorUtility.DisplayDialog(
"Upgrade All UI Text?",
string.Format(
"This option will scan your project for all {0} instances and replace them with {1} objects. " +
"All references to objects and serialized values will remain intact.",
typeof(UnityEngine.UI.Text).FullName, typeof(HyperText).FullName
), "Yes", "No"
)
)
{
return;
}
HyperText ht = new GameObject("DELETE THIS", typeof(HyperText)).GetComponent <HyperText>();
MonoScript script = MonoScript.FromMonoBehaviour(ht);
AssetDatabaseX.ModifyAllComponentsInProject <UnityEngine.UI.Text>(
delegate(UnityEngine.UI.Text text, string assetPath)
{
if (text is HyperText)
{
return;
}
SerializedObject so = new SerializedObject(text);
so.FindProperty("m_Script").objectReferenceValue = script;
so.ApplyModifiedProperties();
}
);
if (ht != null)
{
Object.DestroyImmediate(ht.gameObject);
}
}
private void Rebuild()
{
VisualElement root = rootVisualElement;
root.Clear();
var styleSheet = AssetDatabaseX.LoadAssetWithGUID <StyleSheet>(UssGuid);
var visualTree = AssetDatabaseX.LoadAssetWithGUID <VisualTreeAsset>(UxmlGuid);
var commonStyleSheet = AssetDatabaseX.LoadAssetWithGUID <StyleSheet>(ToolsConstants.Resources.COMMON_STYLES_USS_GUID);
if (styleSheet != null)
{
root.styleSheets.Add(styleSheet);
}
root.styleSheets.Add(commonStyleSheet);
visualTree.CloneTree(root);
var refreshButton = root.Q <Button>(name: "refreshButton");
if (refreshButton != null)
{
refreshButton.clickable.clicked -= Rebuild;
refreshButton.clickable.clicked += Rebuild;
}
Rebuild(root);
}
private static void CleanUpQuads()
{
#pragma warning disable 612
AssetDatabaseX.ModifyAllComponentsInProject <HyperTextQuad>(
(quad, assetPath) => Undo.DestroyObjectImmediate(quad), "Clean Up HyperText Quads in Prefabs"
);
#pragma warning restore 612
}
public ToolsVisualElementBase()
{
var uss = AssetDatabaseX.LoadAssetWithGUID <StyleSheet>(UssGuid);
if (uss != null)
{
styleSheets.Add(uss);
}
styleSheets.Add(AssetDatabaseX.LoadAssetWithGUID <StyleSheet>(ToolsConstants.Resources.COMMON_STYLES_USS_GUID));
VisualTreeAsset visualTree = AssetDatabaseX.LoadAssetWithGUID <VisualTreeAsset>(UxmlGuid);
visualTree.CloneTree(this);
}
public static void UpdateSimAssetIds()
{
SimAssetBank bank = AssetDatabaseX.LoadOrCreateScriptableObjectAsset <SimAssetBank>(ASSET_PATH);
bank.EditorSimAssets.Clear();
AssetDatabaseX.LoadPrefabAssetsWithComponentOnRoot <SimAsset>(out List <KeyValuePair <string, GameObject> > loadResult);
foreach (KeyValuePair <string, GameObject> item in loadResult)
{
var prefab = item.Value.GetComponent <SimAsset>();
ValidateSimAssetIdForPrefab(prefab);
bank.EditorSimAssets.Add(prefab);
}
DebugEditor.LogAssetIntegrity($"[{nameof(SimAssetBankUpdater)}] Updated {typeof(SimAssetBank)}");
EditorUtility.SetDirty(bank);
AssetDatabase.SaveAssets();
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
if (AssetPostprocessorUtility.ExitImportLoop(importedAssets, ASSET_PATH, ref s_importLoopCounter))
{
return;
}
SimAssetBank bank = null;
bool saveAsset = false;
importedAssets.Where((assetPath) => assetPath.EndsWith(".prefab"))
.Select((assetPath) => AssetDatabase.LoadAssetAtPath <GameObject>(assetPath))
.Where((gameObject) => gameObject.GetComponent <SimAsset>() != null)
.Select((gameObject) => gameObject.GetComponent <SimAsset>())
.ToList()
.ForEach((SimAsset prefab) =>
{
if (bank == null)
{
bank = AssetDatabaseX.LoadOrCreateScriptableObjectAsset <SimAssetBank>(ASSET_PATH);
}
saveAsset |= ValidateSimAssetIdForPrefab(prefab);
if (!bank.EditorSimAssets.Contains(prefab))
{
saveAsset = true;
bank.EditorSimAssets.Add(prefab);
DebugEditor.LogAssetIntegrity($"Added {prefab.gameObject.name} to {nameof(SimAssetBank)}.");
}
});
if (saveAsset)
{
EditorUtility.SetDirty(bank);
AssetDatabase.SaveAssets();
}
}
public void UpdateBankComplete()
{
TBank bank = AssetDatabaseX.LoadOrCreateAsset(_bankAssetPath, () => ScriptableObject.CreateInstance <TBank>());
var storedObjects = _getStoredObjectsFromBankDelegate(bank);
storedObjects.Clear();
LoadAll(out List <(string, TAsset)> loadResult);
foreach ((string guid, TAsset asset) in loadResult)
{
if (_evaluateAssetDelegate(asset, out TStoredObject storedObject))
{
storedObjects.Add(storedObject);
}
}
DebugEditor.LogAssetIntegrity($"{bank.name} bank updated.");
EditorUtility.SetDirty(bank);
AssetDatabase.SaveAssets();
}
void SetBlendMode(BlendMode blendMode)
{
Shader shader;
string assetPath;
switch (blendMode)
{
default:
case BlendMode.Add:
shader = _shaderAdd;
assetPath = ASSET_PATH_ADD;
break;
}
Material material = AssetDatabaseX.LoadOrCreateAsset(assetPath, () =>
{
var newMat = new Material(shader);
newMat.enableInstancing = true;
return(newMat);
});
((SpriteLight)target).GetComponent <SpriteRenderer>().sharedMaterial = material;
}
private void UpdateBank(List <TStoredObject> changedPrefabs)
{
TBank bank = AssetDatabaseX.LoadOrCreateAsset(_bankAssetPath, () => ScriptableObject.CreateInstance <TBank>());
var storedObjects = _getStoredObjectsFromBankDelegate(bank);
bool change = false;
foreach (var item in changedPrefabs)
{
if (!storedObjects.Contains(item))
{
storedObjects.Add(item);
change = true;
}
}
if (change)
{
DebugEditor.LogAssetIntegrity($"{bank.name} updated.");
EditorUtility.SetDirty(bank);
AssetDatabase.SaveAssets();
}
}
static void UpdateMetaData(LogMode logMode)
{
SceneMetaDataBank dataAsset = AssetDatabaseX.LoadOrCreateScriptableObjectAsset <SceneMetaDataBank>(ASSET_PATH);
if (dataAsset == null)
{
Debug.LogWarning($"Could not update SceneMetaDataBank. None found at [{ASSET_PATH}]");
return;
}
List <SceneMetaDataBank.SceneMetaData> oldData = dataAsset.SceneMetaDatasInternal;
List <SceneMetaDataBank.SceneMetaData> newData = new List <SceneMetaDataBank.SceneMetaData>();
int buildIndex = 0;
foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
{
SceneMetaDataBank.SceneMetaData metaData = new SceneMetaDataBank.SceneMetaData();
metaData.AssetGuid = scene.guid.ToString();
metaData.Path = scene.path;
metaData.Name = Path.GetFileNameWithoutExtension(scene.path);
metaData.BuildIndex = buildIndex;
newData.Add(metaData);
buildIndex++;
}
dataAsset.SceneMetaDatasInternal = newData;
// fbessette this diff algo could be optimized
if (logMode == LogMode.Full || logMode == LogMode.ChangesOnly)
{
if (oldData != null)
{
for (int i = 0; i < oldData.Count; i++)
{
if (newData.FindIndex((x) => x.AssetGuid == oldData[i].AssetGuid) == -1)
{
DebugEditor.LogAssetIntegrity($"<color=red>Removed scene meta-data:</color> {oldData[i].Name}");
}
}
for (int i = 0; i < newData.Count; i++)
{
int oldDataIndex = oldData.FindIndex((x) => x.AssetGuid == newData[i].AssetGuid);
if (oldDataIndex == -1)
{
DebugEditor.LogAssetIntegrity($"<color=green>Added scene meta-data:</color> {newData[i].Name}");
}
else if (oldData[oldDataIndex].ContentEquals(newData[i]) == false)
{
DebugEditor.LogAssetIntegrity($"<color=green>Updated scene meta-data:</color> {newData[i].Name}");
}
}
}
else
{
for (int i = 0; i < newData.Count; i++)
{
DebugEditor.LogAssetIntegrity($"<color=green>Added scene meta-data:</color> {newData[i].Name}");
}
}
}
if (logMode == LogMode.Full)
{
DebugEditor.LogAssetIntegrity("Scene meta-data bank updated");
}
EditorUtility.SetDirty(dataAsset);
AssetDatabase.SaveAssets();
}
protected override void Rebuild(VisualElement root)
{
_localPlayerProfiles = PlayerProfileService.LoadProfilesOnDisk();
_localPlayerProfileNames = new string[_localPlayerProfiles.Count + 1];
for (int i = 0; i < _localPlayerProfiles.Count; i++)
{
_localPlayerProfileNames[i] = _localPlayerProfiles[i].playerName;
}
_localPlayerProfileNames[_localPlayerProfiles.Count] = "- none -";
_profileElements.Clear();
////////////////////////////////////////////////////////////////////////////////////////
// Build
////////////////////////////////////////////////////////////////////////////////////////
{
var element = root.Q <Button>(name: "buildGame");
element.clickable.clicked += OnClick_BuildGame;
}
{
var element = root.Q <Button>(name: "buildGameAndRun");
element.clickable.clicked += OnClick_BuildGameAndRun;
}
{
var element = root.Q <Button>(name: "openBuildFolder");
element.clickable.clicked += OnClick_OpenBuildFolder;
}
////////////////////////////////////////////////////////////////////////////////////////
// Launch
////////////////////////////////////////////////////////////////////////////////////////
{
var element = root.Q <Toggle>(name: "fromScratch");
var childrenContainer = root.Q <VisualElement>(name: "startingPointContainer");
element.value = EditorLaunchData.playFromScratch;
childrenContainer.EnableInClassList("hidden", element.value);
element.RegisterValueChangedCallback(
(ChangeEvent <bool> changeEvent) =>
{
EditorLaunchData.playFromScratch = changeEvent.newValue;
childrenContainer.EnableInClassList("hidden", changeEvent.newValue);
});
}
{
var container = root.Q <VisualElement>(name: "startingPointContainer");
var levelBank = AssetDatabaseX.LoadAssetsOfType <LevelBank>().FirstOrDefault();
List <string> levels = new List <string>();
levels.Add(""); // the 'none' option
if (levelBank != null)
{
foreach (var item in levelBank.Levels)
{
levels.Add(item.name);
}
levels.Sort();
}
string levelToDisplayName(string level)
{
if (string.IsNullOrEmpty(level))
{
return("- None -");
}
return(level);
}
_elementLevel = new PopupField <string>("Level", levels, 0,
formatSelectedValueCallback: levelToDisplayName,
formatListItemCallback: levelToDisplayName);
container.Insert(0, _elementLevel);
if (levels.Contains(EditorLaunchData.level))
{
_elementLevel.value = EditorLaunchData.level;
}
_elementLevel.RegisterValueChangedCallback(
(ChangeEvent <string> changeEvent) =>
{
EditorLaunchData.level = changeEvent.newValue;
});
}
{
var elementPlayOnline = root.Q <Toggle>(name: "online");
var elementServerName = root.Q <TextField>(name: "serverName");
elementServerName.value = EditorLaunchData.serverName;
elementServerName.RegisterValueChangedCallback(
(ChangeEvent <string> changeEvent) =>
{
EditorLaunchData.serverName = changeEvent.newValue;
});
elementPlayOnline.value = EditorLaunchData.playOnline;
elementPlayOnline.RegisterValueChangedCallback(
(ChangeEvent <bool> changeEvent) =>
{
EditorLaunchData.playOnline = changeEvent.newValue;
for (int i = 0; i < _profileElements.Count; i++)
{
_profileElements[i].UpdateContent();
}
elementServerName.EnableInClassList("hidden", !changeEvent.newValue);
});
elementServerName.EnableInClassList("hidden", !elementPlayOnline.value);
}
{
var element = root.Q <Foldout>(name: "advFoldout");
element.value = false;
element.text = "Advanced";
}
{
var element = root.Q <Toggle>(name: "headless");
element.value = EditorLaunchData.serverIsHeadless;
element.RegisterValueChangedCallback(
(ChangeEvent <bool> changeEvent) =>
{
EditorLaunchData.serverIsHeadless = changeEvent.newValue;
});
}
{
var element = root.Q <TextField>(name: "extraArgs");
element.value = EditorLaunchData.extraArguments;
element.RegisterValueChangedCallback(
(ChangeEvent <string> changeEvent) =>
{
GameConsole.EditorPlayCommands = CommandLine.SplitCommandLineInGroups(changeEvent.newValue).ToArray();
EditorLaunchData.extraArguments = changeEvent.newValue;
});
}
{
var element = root.Q <Toggle>(name: "overrideScreen");
var childrenContainer = root.Q <VisualElement>(name: "overrideScreenContainer");
element.value = EditorLaunchData.launchOverrideScreen;
childrenContainer.EnableInClassList("hidden", !element.value);
element.RegisterValueChangedCallback(
(ChangeEvent <bool> changeEvent) =>
{
EditorLaunchData.launchOverrideScreen = changeEvent.newValue;
childrenContainer.EnableInClassList("hidden", !changeEvent.newValue);
});
}
{
var element = root.Q <Toggle>(name: "fullscreen");
element.value = EditorLaunchData.launchFullscreen;
element.RegisterValueChangedCallback(
(ChangeEvent <bool> changeEvent) =>
{
EditorLaunchData.launchFullscreen = changeEvent.newValue;
});
}
{
var element = root.Q <IntegerField>(name: "screenWidth");
element.value = EditorLaunchData.launchScreenWidth;
element.RegisterValueChangedCallback(
(ChangeEvent <int> changeEvent) =>
{
EditorLaunchData.launchScreenWidth = changeEvent.newValue;
});
}
{
var element = root.Q <IntegerField>(name: "screenHeight");
element.value = EditorLaunchData.launchScreenHeight;
element.RegisterValueChangedCallback(
(ChangeEvent <int> changeEvent) =>
{
EditorLaunchData.launchScreenHeight = changeEvent.newValue;
});
}
{
var element = root.Q <VisualElement>(name: "profilesContainer");
int whoIsServer = EditorLaunchData.whoIsServerId;
int whoIsEditor = EditorLaunchData.whoIsEditorId;
for (int i = 0; i < _localPlayerProfiles.Count; i++)
{
PlayerProfile profile = _localPlayerProfiles[i];
LaunchProfileElement newElement = new LaunchProfileElement(profile)
{
IsMarkedAsServer = (whoIsServer == profile.localId),
IsMarkedAsEditor = (whoIsEditor == profile.localId),
};
newElement.focusable = true;
newElement.pickingMode = PickingMode.Position;
newElement.AddManipulator(new ContextualMenuManipulator((ContextualMenuPopulateEvent evt) =>
{
evt.menu.AppendAction("Set Server", (DropdownMenuAction action) =>
{
if (newElement.IsMarkedAsServer)
{
SetAsServer(null);
}
else
{
SetAsServer(newElement);
}
}, status: newElement.IsMarkedAsServer?DropdownMenuAction.Status.Checked: DropdownMenuAction.Status.Normal);
evt.menu.AppendAction("Set Editor", (DropdownMenuAction action) =>
{
if (newElement.IsMarkedAsEditor)
{
SetAsEditor(null);
}
else
{
SetAsEditor(newElement);
}
}, status: newElement.IsMarkedAsEditor?DropdownMenuAction.Status.Checked: DropdownMenuAction.Status.Normal);
}));
_profileElements.Add(newElement);
element.Add(newElement);
}
}
UpdateFromScenes();
}
private static void ValidateRaycastTargets()
{
if (
!EditorUtility.DisplayDialog(
"Validate HyperText Raycast Targets?",
string.Format(
"This option will scan your project for all {0} instances that are children of {1} or {2} " +
"objects (such as e.g., Buttons) but also have the raycastTarget property enabled and have " +
"links defined. Links on these instances will block input events. Results will be logged to " +
"the console.\n\nDo you wish to proceed?",
typeof(HyperText).Name,
typeof(UnityEngine.EventSystems.IPointerClickHandler).Name,
typeof(UnityEngine.EventSystems.IPointerDownHandler).Name
), "Yes", "No"
)
)
{
return;
}
System.Type logEntries =
ReflectionX.AllTypes.FirstOrDefault(t => t.FullName == "UnityEditorInternal.LogEntries");
if (logEntries != null)
{
System.Reflection.MethodInfo clear = logEntries.GetStaticMethod("Clear");
if (clear != null)
{
clear.Invoke(null, null);
}
}
bool isSilent = HyperText.IsSilent;
HyperText.IsSilent = true;
string undoName = "Validate HyperText Raycast Targets";
System.Reflection.MethodInfo getWarningMessage =
typeof(HyperText).GetInstanceMethod("GetInputBlockingWarningMessage");
AssetDatabaseX.ModifyAssetCallback <HyperText> validateRaycastTarget =
delegate(HyperText hyperText, string assetPath)
{
if (!hyperText.raycastTarget)
{
return;
}
#if UNITY_4_6 || UNITY_4_7
s_ClickHandlers.Clear();
s_DownHandlers.Clear();
s_ClickHandlers.AddRange(
hyperText.GetComponentsInParent(
typeof(UnityEngine.EventSystems.IPointerClickHandler), true
).Cast <UnityEngine.EventSystems.IPointerClickHandler>()
);
s_DownHandlers.AddRange(
hyperText.GetComponentsInParent(
typeof(UnityEngine.EventSystems.IPointerDownHandler), true
).Cast <UnityEngine.EventSystems.IPointerDownHandler>()
);
#else
hyperText.GetComponentsInParent(true, s_ClickHandlers);
hyperText.GetComponentsInParent(true, s_DownHandlers);
#endif
s_ClickHandlers.Remove(hyperText);
s_DownHandlers.Remove(hyperText);
if (s_ClickHandlers.Count > 0 || s_DownHandlers.Count > 0)
{
using (ListPool <HyperText.LinkInfo> .Scope links = new ListPool <HyperText.LinkInfo> .Scope())
{
if (hyperText.GetLinks(links.List) > 0)
{
string warningMessage = getWarningMessage.Invoke(hyperText, null) as string;
if (!string.IsNullOrEmpty(warningMessage))
{
Debug.LogWarning(
string.Format(
"{0}\n<b>{1}</b> at {2}\n", warningMessage, hyperText.name, assetPath
), hyperText
);
}
}
}
}
};
AssetDatabaseX.ModifyAllComponentsInProject(validateRaycastTarget, undoName);
HyperText.IsSilent = isSilent;
}
public static void CreateNewAssetInProject()
{
AssetDatabaseX.CreateNewAssetInCurrentProjectFolder <HyperTextStyles>();
}
public static void CreateNewAssetInProject()
{
AssetDatabaseX.CreateNewAssetInCurrentProjectFolder <LocalizableText>();
}
