private void SetObjectName()
{
var origName = TargetType.name;
TargetType.name = prefix + origName;
AssetDatabaseUtils.UpdateNameOfObject(TargetType);
}
public static void Uninstall()
{
bool _startUninstall = EditorUtility.DisplayDialog(kUninstallAlertTitle, kUninstallAlertMessage, "Uninstall", "Cancel");
if (_startUninstall)
{
foreach (string _eachFolder in kPluginFolders)
{
string _absolutePath = AssetDatabaseUtils.AssetPathToAbsolutePath(_eachFolder);
if (Directory.Exists(_absolutePath))
{
Directory.Delete(_absolutePath, true);
// Delete meta files.
FileOperations.Delete(_absolutePath + ".meta");
}
}
AssetDatabase.Refresh();
EditorUtility.DisplayDialog("Cross Platform Replay Kit",
"Uninstall successful!",
"Ok");
}
}
public static void Uninstall()
{
bool _startUninstall = EditorUtility.DisplayDialog(kUninstallAlertTitle, kUninstallAlertMessage, "Uninstall", "Cancel");
if (_startUninstall)
{
foreach (string _eachFolder in kPluginFolders)
{
string _absolutePath = AssetDatabaseUtils.AssetPathToAbsolutePath(_eachFolder);
if (Directory.Exists(_absolutePath))
{
Directory.Delete(_absolutePath, true);
// Delete meta files.
FileOperations.Delete(_absolutePath + ".meta");
}
}
// For LITE version we need to remove defines.
GlobalDefinesManager _definesManager = new GlobalDefinesManager();
foreach (int _eachCompiler in System.Enum.GetValues(typeof(GlobalDefinesManager.eCompiler)))
{
_definesManager.RemoveDefineSymbol((GlobalDefinesManager.eCompiler)_eachCompiler, NPSettings.kLiteVersionMacro);
}
_definesManager.SaveAllCompilers();
AssetDatabase.Refresh();
EditorUtility.DisplayDialog("Cross Platform Native Plugins",
"Uninstall successful!",
"Ok");
}
}
void objectDisplay(string guid)
{
EditorGUILayout.BeginHorizontal();
var obj = AssetDatabaseUtils.loadMainAssetByGuid(guid);
EditorGUILayout.ObjectField(obj, typeof(Object), false);
var etype = Event.current.type;
if (etype == EventType.MouseMove)
{
var info = typeof(EditorGUILayout).GetField("s_LastRect", BindingFlags.NonPublic | BindingFlags.Static);
// ReSharper disable once PossibleNullReferenceException
var rect = (Rect)info.GetValue(null);
var mousePos = Event.current.mousePosition;
if (rect.Contains(mousePos))
{
hoverItem = obj;
}
}
if (GUILayout.Button("", GUILayout.MaxWidth(30)))
{
Selection.activeObject = obj;
}
EditorGUILayout.EndHorizontal();
}
private GraphNode AddNewNode(ActionGraphNodeBase node)
{
AssetDatabaseUtils.AddToAsset(Asset, node);
switch (node)
{
case ActionGraphNode asAction:
{
Asset.Nodes.Add(asAction);
break;
}
case AnyEntry asAnyEntry:
{
Asset.AnyEntryNode = asAnyEntry;
break;
}
case EventEntry asEntry:
{
Asset.NamedEventEntries.Add(asEntry);
break;
}
default:
{
Debug.LogError($"Unknown node {node}!");
break;
}
}
return(View.OnNodeAdded(Asset, node));
}
public static void FindMissingReferencesMenu()
{
int missingCount = 0;
var gameObjects = AssetDatabaseUtils.FindAndLoadAssets <GameObject>();
Debug.LogFormat("Searching <b>{0}</b> AssetDatabase GameObjects for missing references", gameObjects.Count);
foreach (var go in gameObjects)
{
missingCount += FindMissingReferences(go);
}
var sceneGameObjects = Resources.FindObjectsOfTypeAll <GameObject>();
Debug.LogFormat("Searching <b>{0}</b> Scene GameObjects for missing references", sceneGameObjects.Length);
foreach (var go in sceneGameObjects)
{
missingCount += FindMissingReferences(go);
}
var logString = string.Format("<b>Completed search, {0} missing references</b>", missingCount);
if (missingCount > 0)
{
Debug.LogError(logString);
}
else
{
Debug.Log(logString);
}
}
public static UnityObject LoadAsset(this string s, Type t)
{
if (s.IsEmpty())
{
return(null);
}
if (s.StartWithAssets())
{
return(AssetDatabase.LoadAssetAtPath(s, t));
}
return(AssetDatabaseUtils.LoadAssetAtGUID(s, t));
}
public void WriteAndroidManifestFile()
{
string _manifestFolderPath = Constants.kAndroidPluginsReplayKitPath;
if (AssetDatabaseUtils.FolderExists(_manifestFolderPath))
{
ReplayKitAndroidManifestGenerator _generator = new ReplayKitAndroidManifestGenerator();
#if UNITY_2017_4_OR_NEWER
_generator.SaveManifest("com.voxelbusters.replaykitplugin", _manifestFolderPath + "/AndroidManifest.xml", "16", "28");
#else
_generator.SaveManifest("com.voxelbusters.replaykitplugin", _manifestFolderPath + "/AndroidManifest.xml", "16", "26");
#endif
}
}
private void WriteAndroidManifestFile()
{
string _manifestFolderPath = Constants.kAndroidPluginsLibraryPath;
if (AssetDatabaseUtils.FolderExists(_manifestFolderPath))
{
NPAndroidManifestGenerator _generator = new NPAndroidManifestGenerator();
#if UNITY_2017_1_OR_NEWER
_generator.SaveManifest("com.voxelbusters.androidnativeplugin", _manifestFolderPath + "/AndroidManifest.xml", "9", "26");
#else
_generator.SaveManifest("com.voxelbusters.androidnativeplugin", _manifestFolderPath + "/AndroidManifest.xml", "9", "24");
#endif
}
}
private static void DecompressTwitterSDKFiles()
{
string _projectPath = AssetDatabaseUtils.GetProjectPath();
string _twitterNativeCodeFolderPath = Path.Combine(_projectPath, kRelativePathIOSNativeCodeFolder + "/Twitter");
if (!Directory.Exists(_twitterNativeCodeFolderPath))
{
return;
}
foreach (string _filePath in Directory.GetFiles(_twitterNativeCodeFolderPath, "*.gz", SearchOption.AllDirectories))
{
Zip.DecompressToDirectory(_filePath, kRelativePathNativePluginsSDKFolder);
}
}
private void OnConditionAdded(ReorderableList list, Type type)
{
var instance = ScriptableObject.CreateInstance(type) as Condition;
list.ListUnsafe.GetAs <TConditionList>()?.Add(instance);
AssetDatabaseUtils.AddToParentAsset(list.List.serializedObject.targetObject, instance);
// Set Graph reference
var path = AssetDatabase.GetAssetPath(list.List.serializedObject.targetObject);
if (!string.IsNullOrEmpty(path))
{
var parent = AssetDatabase.LoadAssetAtPath(path, typeof(ActionGraph));
instance.Graph = parent as ActionGraph;
}
}
public void Populate()
{
StateMachineReferences.Clear();
foreach (var propertyPath in AssetDatabaseUtils.GetAssetRelativePaths(FolderPath, true))
{
StateMachineGraph assetAsStateMachine =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(StateMachineGraph)) as StateMachineGraph;
if (assetAsStateMachine != null)
{
StateMachineReference stateMachineReference = new StateMachineReference();
stateMachineReference.StateMachine = assetAsStateMachine;
StateMachineReferences.Add(stateMachineReference);
continue;
}
}
}
public static T LoadOrCreateInstance()
{
if (!TryToLoadInstance(out T resultInstance))
{
#if !UNITY_EDITOR
return(null);
#else
resultInstance = CreateInstance <T>();
AssetDatabaseUtils.CreatePathIfDontExist("Assets/Resources");
UnityEditor.AssetDatabase.CreateAsset(resultInstance, $"Assets/Resources/{typeof(T).Name}.asset");
UnityEditor.AssetDatabase.SaveAssets();
UnityEditor.AssetDatabase.Refresh();
return(resultInstance);
#endif
}
return(resultInstance);
}
public static T2 LoadOrCreateInstance <T2>() where T2 : ScriptableObject
{
T2 newInstance = Resources.Load <T2>(typeof(T2).Name);
if (newInstance != null)
{
return(newInstance);
}
#if UNITY_EDITOR
if (Application.isPlaying)
{
return(null);
}
string registryGUID = UnityEditor.AssetDatabase.FindAssets($"t:{typeof(T2).Name}")
.FirstOrDefault();
if (!string.IsNullOrEmpty(registryGUID))
{
newInstance = (T2)UnityEditor.AssetDatabase.LoadAssetAtPath <ScriptableObject>(
UnityEditor.AssetDatabase.GUIDToAssetPath(registryGUID));
}
if (newInstance != null)
{
return(newInstance);
}
newInstance = CreateInstance <T2>();
AssetDatabaseUtils.CreatePathIfDontExist("Assets/Resources");
UnityEditor.AssetDatabase.CreateAsset(newInstance, $"Assets/Resources/{typeof(T2).Name}.asset");
UnityEditor.AssetDatabase.SaveAssets();
UnityEditor.AssetDatabase.Refresh();
return(newInstance);
#endif
#pragma warning disable CS0162
return(null);
#pragma warning restore CS0162
}
public static void FindReferencesMenu()
{
var guids = Selection.assetGUIDs;
if (guids == null)
{
Debug.LogError("No selection!");
return;
}
var guid = guids[0];
var asset = AssetDatabaseUtils.LoadAssetByGUID <Object>(guid);
if (asset == null)
{
Debug.LogError("Couldn't load asset!");
return;
}
int countFound = 0;
var gameObjects = AssetDatabaseUtils.FindAndLoadAssets <GameObject>();
Debug.LogFormat(asset, "Searching <b>{0}</b> AssetDatabase GameObjects for references to: <b>{1}</b>", gameObjects.Count, asset.name);
foreach (var go in gameObjects)
{
countFound += FindReferences(asset, go);
}
var sceneGameObjects = Resources.FindObjectsOfTypeAll <GameObject>();
Debug.LogFormat(asset, "Searching <b>{0}</b> Scene GameObjects for references to: <b>{1}</b>", sceneGameObjects.Length, asset.name);
foreach (var go in sceneGameObjects)
{
countFound += FindReferences(asset, go);
}
Debug.LogFormat(asset, "<b>Completed search, {0} references found</b>", countFound);
}
void displayObjects(string name, ICollection <string> guids, ref bool foldout)
{
foldout = EditorGUILayout.Foldout(foldout, name + " " + guids.Count);
if (foldout)
{
if (showActions)
{
if (GUILayout.Button("select"))
{
Selection.objects = loadGuids(guids).ToArray();
}
if (GUILayout.Button("set dirty"))
{
var objects = loadGuids(guids).ToArray();
Undo.RecordObjects(objects, "Set objects dirty");
foreach (var o in objects)
{
EditorUtility.SetDirty(o);
}
}
}
foreach (var guid in guids.OrderBy(AssetDatabase.GUIDToAssetPath))
{
var asset = AssetDatabaseUtils.loadMainAssetByGuid(guid);
if (asset != null)
{
objectDisplay(guid);
}
else
{
GUILayout.Label(AssetDatabase.GUIDToAssetPath(guid));
}
}
}
}
private static T SetSO <T>(ref string newPath, bool focus, T asset) where T : ScriptableObject
{
if (!newPath.StartsWith("Assets/") && !newPath.StartsWith("Assets\\"))
{
newPath = "Assets/" + newPath;
}
AssetDatabaseUtils.RequestPath(newPath);
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(newPath + ".asset");
Debug.Log("Try create asset at " + assetPathAndName);
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
if (focus)
{
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
}
return(asset);
}
public void PopulateContainer()
{
TriggerVariables.Clear();
BoolVariables.Clear();
IntVariables.Clear();
FloatVariables.Clear();
Vector2Variables.Clear();
Vector3Variables.Clear();
QuaternionVariables.Clear();
TimerVariables.Clear();
foreach (var propertyPath in AssetDatabaseUtils.GetAssetRelativePaths(FolderPath, IncludeSubdirectories))
{
TriggerVariable assetAsTrigger =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TriggerVariable)) as TriggerVariable;
if (assetAsTrigger != null)
{
TriggerVariables.Add(assetAsTrigger);
continue;
}
BoolVariable assetAsBool =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(BoolVariable)) as BoolVariable;
if (assetAsBool != null)
{
BoolVariables.Add(assetAsBool);
continue;
}
IntVariable assetAsInt =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(IntVariable)) as IntVariable;
if (assetAsInt != null)
{
IntVariables.Add(assetAsInt);
continue;
}
FloatVariable assetAsFloat =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(FloatVariable)) as FloatVariable;
if (assetAsFloat != null)
{
FloatVariables.Add(assetAsFloat);
continue;
}
Vector2Variable assetAsVector2 =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(Vector2Variable)) as Vector2Variable;
if (assetAsVector2 != null)
{
Vector2Variables.Add(assetAsVector2);
continue;
}
Vector3Variable assetAsVector3 =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(Vector3Variable)) as Vector3Variable;
if (assetAsVector3 != null)
{
Vector3Variables.Add(assetAsVector3);
continue;
}
QuaternionVariable assetAsQuaternion =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(QuaternionVariable)) as QuaternionVariable;
if (assetAsQuaternion != null)
{
QuaternionVariables.Add(assetAsQuaternion);
continue;
}
TimerVariable assetAsTimer =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TimerVariable)) as TimerVariable;
if (assetAsTimer != null)
{
TimerVariables.Add(assetAsTimer);
continue;
}
FunctionVariable assetAsFunction =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TimerVariable)) as FunctionVariable;
if (assetAsFunction != null)
{
FunctionVariables.Add(assetAsFunction);
continue;
}
}
Debug.Log($"{TriggerVariables.Count} Triggers" +
$" | {BoolVariables.Count} Bools" +
$" | {IntVariables.Count} Ints" +
$" | {FloatVariables.Count} Floats" +
$" | {Vector2Variables.Count} Vector2s" +
$" | {Vector3Variables.Count} Vector3s" +
$" | {QuaternionVariables.Count} Quaternions" +
$" | {TimerVariables.Count} Timers" +
$" | {FunctionVariables.Count} Functions");
}
public static UnityObject[] LoadAllSubAssets(this string s)
{
return(AssetDatabaseUtils.LoadAllSubAssets(s));
}
