private static void DrawHashSection()
{
using (var changed = new EditorGUI.ChangeCheckScope())
{
var betaColor = ColorTools.GetPurpleString();
var fold = GUITools.DrawFoldHeader("Code Hash Generator <color=#" + betaColor + ">BETA</color>", ACTkEditorPrefsSettings.HashFoldout);
if (changed.changed)
{
ACTkEditorPrefsSettings.HashFoldout = fold;
}
}
if (!ACTkEditorPrefsSettings.HashFoldout)
{
return;
}
GUILayout.Space(-3f);
using (GUITools.Vertical(GUITools.PanelWithBackground))
{
var option = ACTkSettings.Instance.PreGenerateBuildHash;
EditorGUI.BeginChangeCheck();
option = EditorGUILayout.ToggleLeft(new GUIContent("Generate code hash on build completion", "Generates hash after build is finished, prints it to the console & sends it via CodeHashGeneratorPostprocessor."), option);
if (EditorGUI.EndChangeCheck())
{
ACTkSettings.Instance.PreGenerateBuildHash = option;
}
EditorGUILayout.Space();
GUILayout.Label("Can differ from runtime hash if you post-process code in resulting build (e.g. obfuscate, compress, etc.).", GUITools.RichLabel);
GUILayout.Space(5f);
EditorGUILayout.HelpBox("Always make sure post-build hash equals runtime one if you're using it for later comparison",
MessageType.Info, true);
if (!CodeHashGenerator.IsTargetPlatformCompatible())
{
EditorGUILayout.HelpBox("Current platform is not supported: Windows or Android required",
MessageType.Warning, true);
}
GUILayout.Space(3);
}
}
public static void OnGUI()
{
GUITools.Separator();
DrawSettingsHeader();
GUILayout.Space(5f);
DrawIL2CPPSection();
EditorGUILayout.Space();
DrawInjectionSection();
EditorGUILayout.Space();
DrawHashSection();
EditorGUILayout.Space();
DrawWallHackSection();
EditorGUILayout.Space();
DrawConditionalSection();
}
private static void DrawWallHackSection()
{
using (var changed = new EditorGUI.ChangeCheckScope())
{
var fold = GUITools.DrawFoldHeader("WallHack Detector", ACTkEditorPrefsSettings.WallHackFoldout);
if (changed.changed)
{
ACTkEditorPrefsSettings.WallHackFoldout = fold;
}
}
if (!ACTkEditorPrefsSettings.WallHackFoldout)
{
return;
}
GUILayout.Space(-3f);
using (GUITools.Vertical(GUITools.PanelWithBackground))
{
GUILayout.Label(
"Wireframe module uses own shader under the hood and it should be included into the build.",
EditorStyles.wordWrappedLabel);
ReadGraphicsAsset();
if (graphicsSettingsAsset != null && includedShaders != null)
{
// outputs whole included shaders list, use for debug
//EditorGUILayout.PropertyField(includedShaders, true);
var shaderIndex = GetWallhackDetectorShaderIndex();
EditorGUI.BeginChangeCheck();
var status = shaderIndex != -1 ? ColorTools.GetGreenString() + ">included" : ColorTools.GetRedString() + ">not included";
GUILayout.Label("Shader status: <color=#" + status + "</color>", GUITools.RichLabel);
GUILayout.Space(5f);
EditorGUILayout.HelpBox("You don't need to include it if you're not going to use Wireframe module",
MessageType.Info, true);
GUILayout.Space(5f);
if (shaderIndex != -1)
{
if (GUILayout.Button("Remove shader"))
{
includedShaders.DeleteArrayElementAtIndex(shaderIndex);
includedShaders.DeleteArrayElementAtIndex(shaderIndex);
}
GUILayout.Space(3);
}
else
{
using (GUITools.Horizontal())
{
if (GUILayout.Button("Auto Include"))
{
var shader = Shader.Find(WallHackDetector.WireframeShaderName);
if (shader != null)
{
includedShaders.InsertArrayElementAtIndex(includedShaders.arraySize);
var newItem = includedShaders.GetArrayElementAtIndex(includedShaders.arraySize - 1);
newItem.objectReferenceValue = shader;
}
else
{
Debug.LogError(ACTkConstants.LogPrefix + "Can't find " + WallHackDetector.WireframeShaderName +
" shader! Please report this to the " +
ACTkEditorConstants.SupportEmail +
" including your Unity version number.");
}
}
if (GUILayout.Button("Include manually (see readme.pdf)"))
{
#if UNITY_2018_3_OR_NEWER
SettingsService.OpenProjectSettings("Project/Graphics");
#else
EditorApplication.ExecuteMenuItem("Edit/Project Settings/Graphics");
#endif
}
}
GUILayout.Space(3);
}
if (EditorGUI.EndChangeCheck())
{
graphicsSettingsAsset.ApplyModifiedProperties();
}
}
else
{
GUILayout.Label("Can't automatically control " + WallHackDetector.WireframeShaderName +
" shader existence at the Always Included Shaders list. Please, manage this manually in Graphics Settings.");
if (GUILayout.Button("Open Graphics Settings"))
{
EditorApplication.ExecuteMenuItem("Edit/Project Settings/Graphics");
}
}
}
}
private static void DrawInjectionSection()
{
using (var changed = new EditorGUI.ChangeCheckScope())
{
var fold = GUITools.DrawFoldHeader("Injection Detector", ACTkEditorPrefsSettings.InjectionFoldout);
if (changed.changed)
{
ACTkEditorPrefsSettings.InjectionFoldout = fold;
}
}
if (!ACTkEditorPrefsSettings.InjectionFoldout)
{
return;
}
GUILayout.Space(-3f);
using (GUITools.Vertical(GUITools.PanelWithBackground))
{
var enableInjectionDetector = ACTkSettings.Instance.InjectionDetectorEnabled;
if (SettingsUtils.IsIL2CPPEnabled())
{
EditorGUILayout.HelpBox("Injection is not possible in IL2CPP,\n" +
"this detector is not needed in IL2CPP builds", MessageType.Info, true);
GUILayout.Space(5f);
}
else if (!InjectionRoutines.IsTargetPlatformCompatible())
{
EditorGUILayout.HelpBox(
"Injection Detection is only supported in non-IL2CPP Standalone and Android builds",
MessageType.Warning, true);
GUILayout.Space(5f);
}
using (new GUILayout.HorizontalScope())
{
EditorGUI.BeginChangeCheck();
enableInjectionDetector = EditorGUILayout.ToggleLeft(new GUIContent(
"Add mono injection detection support to build",
"Injection Detector checks assemblies against whitelist. " +
"Please enable this option if you're using Injection Detector " +
"and default whitelist will be generated while Unity builds resulting build.\n" +
"Has no effect for IL2CPP or unsupported platforms."), enableInjectionDetector
);
if (EditorGUI.EndChangeCheck())
{
ACTkSettings.Instance.InjectionDetectorEnabled = enableInjectionDetector;
}
}
GUILayout.Space(3);
if (GUILayout.Button(new GUIContent(
"Edit Custom Whitelist (" + ACTkSettings.Instance.InjectionDetectorWhiteList.Count + ")",
"Fill any external assemblies which are not included into the project to the user-defined whitelist to make Injection Detector aware of them."))
)
{
UserWhitelistEditor.ShowWindow();
}
GUILayout.Space(3);
}
}
protected void DrawRecord(int recordIndex, out bool recordRemoved)
{
recordRemoved = false;
var record = filteredRecords[recordIndex];
GUITools.Separator();
using (GUITools.Horizontal(GUITools.PanelWithBackground))
{
if (GUILayout.Button(new GUIContent("X", "Delete this pref."), GUITools.CompactButton, GUILayout.Width(20)))
{
record.Delete();
allRecords.Remove(record);
filteredRecords.Remove(record);
recordRemoved = true;
return;
}
GUI.enabled = (record.dirtyValue || record.dirtyKey) && record.prefType != PrefsRecord.PrefsType.Unknown;
if (GUILayout.Button(new GUIContent("S", "Save changes in this pref."), GUITools.CompactButton, GUILayout.Width(20)))
{
record.Save();
GUIUtility.keyboardControl = 0;
}
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
if (record.Obscured)
{
GUI.enabled &= record.obscuredType == ObscuredPrefs.DataType.String ||
record.obscuredType == ObscuredPrefs.DataType.Int ||
record.obscuredType == ObscuredPrefs.DataType.Float;
if (GUILayout.Button(new GUIContent("D", "Decrypt this pref using ObscuredPrefs"), GUITools.CompactButton, GUILayout.Width(25)))
{
record.Decrypt();
GUIUtility.keyboardControl = 0;
}
}
else
{
if (GUILayout.Button(new GUIContent("E", "Encrypt this pref using ObscuredPrefs"), GUITools.CompactButton, GUILayout.Width(25)))
{
record.Encrypt();
GUIUtility.keyboardControl = 0;
}
}
GUI.enabled = true;
if (GUILayout.Button(new GUIContent("...", "Other operations"), GUITools.CompactButton, GUILayout.Width(25)))
{
ShowOtherMenu(record);
}
var guiColor = GUI.color;
if (record.Obscured)
{
GUI.color = obscuredColor;
}
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
if (record.Obscured && !(record.obscuredType == ObscuredPrefs.DataType.String ||
record.obscuredType == ObscuredPrefs.DataType.Int ||
record.obscuredType == ObscuredPrefs.DataType.Float))
{
GUI.enabled = false;
EditorGUILayout.TextField(record.Key, GUILayout.MaxWidth(200), GUILayout.MinWidth(50));
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
}
else
{
record.Key = EditorGUILayout.TextField(record.Key, GUILayout.MaxWidth(200), GUILayout.MinWidth(50));
}
if ((record.prefType == PrefsRecord.PrefsType.String && !record.Obscured) || (record.Obscured && record.obscuredType == ObscuredPrefs.DataType.String))
{
// to avoid TextMeshGenerator error because of too much characters
if (record.StringValue.Length > 16382)
{
GUI.enabled = false;
EditorGUILayout.TextField(StringTooLong, GUILayout.MinWidth(150));
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
}
else
{
record.StringValue = EditorGUILayout.TextField(record.StringValue, GUILayout.MinWidth(150));
}
}
else if (record.prefType == PrefsRecord.PrefsType.Int || (record.Obscured && record.obscuredType == ObscuredPrefs.DataType.Int))
{
record.IntValue = EditorGUILayout.IntField(record.IntValue, GUILayout.MinWidth(150));
}
else if (record.prefType == PrefsRecord.PrefsType.Float || (record.Obscured && record.obscuredType == ObscuredPrefs.DataType.Float))
{
record.FloatValue = EditorGUILayout.FloatField(record.FloatValue, GUILayout.MinWidth(150));
}
else if (record.Obscured)
{
GUI.enabled = false;
EditorGUILayout.TextField(UnsupportedValueDescription, GUILayout.MinWidth(150));
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
}
else
{
GUI.enabled = false;
EditorGUILayout.TextField(UnknownValueDescription, GUILayout.MinWidth(150));
GUI.enabled = record.prefType != PrefsRecord.PrefsType.Unknown;
}
GUI.color = guiColor;
GUI.enabled = true;
EditorGUILayout.LabelField(record.DisplayType, GUILayout.Width(70));
}
}
private void DrawRecordsPages()
{
recordsTotalPages = Math.Max(1, (int)Math.Ceiling((double)filteredRecords.Count / RecordsPerPage));
if (recordsCurrentPage < 0)
{
recordsCurrentPage = 0;
}
if (recordsCurrentPage + 1 > recordsTotalPages)
{
recordsCurrentPage = recordsTotalPages - 1;
}
var fromRecord = recordsCurrentPage * RecordsPerPage;
var toRecord = fromRecord + Math.Min(RecordsPerPage, filteredRecords.Count - fromRecord);
if (recordsTotalPages > 1)
{
GUILayout.Label("Prefs " + fromRecord + " - " + toRecord + " from " + filteredRecords.Count);
}
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
for (var i = fromRecord; i < toRecord; i++)
{
bool recordRemoved;
DrawRecord(i, out recordRemoved);
if (recordRemoved)
{
break;
}
}
GUILayout.EndScrollView();
if (recordsTotalPages <= 1)
{
return;
}
GUILayout.Space(5);
using (GUITools.Horizontal())
{
GUILayout.FlexibleSpace();
GUI.enabled = recordsCurrentPage > 0;
if (GUILayout.Button("<<", GUILayout.Width(50)))
{
RemoveNotification();
recordsCurrentPage = 0;
scrollPosition = Vector2.zero;
}
if (GUILayout.Button("<", GUILayout.Width(50)))
{
RemoveNotification();
recordsCurrentPage--;
scrollPosition = Vector2.zero;
}
GUI.enabled = true;
GUILayout.Label(recordsCurrentPage + 1 + " of " + recordsTotalPages, GUITools.CenteredLabel, GUILayout.Width(100));
GUI.enabled = recordsCurrentPage < recordsTotalPages - 1;
if (GUILayout.Button(">", GUILayout.Width(50)))
{
RemoveNotification();
recordsCurrentPage++;
scrollPosition = Vector2.zero;
}
if (GUILayout.Button(">>", GUILayout.Width(50)))
{
RemoveNotification();
recordsCurrentPage = recordsTotalPages - 1;
scrollPosition = Vector2.zero;
}
GUI.enabled = true;
GUILayout.FlexibleSpace();
}
}
// -------------------------------------------------------------------
// GUI
// -------------------------------------------------------------------
private void OnGUI()
{
if (allRecords == null)
{
allRecords = new List <PrefsRecord>();
}
if (filteredRecords == null)
{
filteredRecords = new List <PrefsRecord>();
}
using (GUITools.Horizontal(GUITools.Toolbar))
{
if (GUILayout.Button(new GUIContent("+", "Create new prefs record."), EditorStyles.toolbarButton, GUILayout.Width(20)))
{
addingNewRecord = true;
}
if (GUILayout.Button(new GUIContent("Refresh", "Re-read and re-parse all prefs."), EditorStyles.toolbarButton, GUILayout.Width(50)))
{
RefreshData();
GUIUtility.keyboardControl = 0;
scrollPosition = Vector2.zero;
recordsCurrentPage = 0;
}
EditorGUI.BeginChangeCheck();
sortingType = (SortingType)EditorGUILayout.EnumPopup(sortingType, EditorStyles.toolbarDropDown, GUILayout.Width(110));
if (EditorGUI.EndChangeCheck())
{
ApplySorting();
}
GUILayout.Space(10);
EditorGUI.BeginChangeCheck();
searchPattern = GUITools.SearchToolbar(searchPattern);
if (EditorGUI.EndChangeCheck())
{
ApplyFiltering();
}
}
if (addingNewRecord)
{
using (GUITools.Horizontal(GUITools.PanelWithBackground))
{
string[] types = { "String", "Int", "Float" };
newRecordType = EditorGUILayout.Popup(newRecordType, types, GUILayout.Width(50));
newRecordEncrypted = GUILayout.Toggle(newRecordEncrypted, new GUIContent("E", "Create new pref as encrypted ObscuredPref?"), GUITools.CompactButton, GUILayout.Width(25));
var guiColor = GUI.color;
if (newRecordEncrypted)
{
GUI.color = obscuredColor;
}
GUILayout.Label("Key:", GUILayout.ExpandWidth(false));
newRecordKey = EditorGUILayout.TextField(newRecordKey);
GUILayout.Label("Value:", GUILayout.ExpandWidth(false));
if (newRecordType == 0)
{
newRecordStringValue = EditorGUILayout.TextField(newRecordStringValue);
}
else if (newRecordType == 1)
{
newRecordIntValue = EditorGUILayout.IntField(newRecordIntValue);
}
else
{
newRecordFloatValue = EditorGUILayout.FloatField(newRecordFloatValue);
}
GUI.color = guiColor;
if (GUILayout.Button("OK", GUITools.CompactButton, GUILayout.Width(30)))
{
if (string.IsNullOrEmpty(newRecordKey) ||
(newRecordType == 0 && string.IsNullOrEmpty(newRecordStringValue)) ||
(newRecordType == 1 && newRecordIntValue == 0) ||
(newRecordType == 2 && Math.Abs(newRecordFloatValue) < 0.00000001f))
{
ShowNotification(new GUIContent("Please fill in the pref first!"));
}
else
{
PrefsRecord newRecord;
if (newRecordType == 0)
{
newRecord = new PrefsRecord(newRecordKey, newRecordStringValue, newRecordEncrypted);
}
else if (newRecordType == 1)
{
newRecord = new PrefsRecord(newRecordKey, newRecordIntValue, newRecordEncrypted);
}
else
{
newRecord = new PrefsRecord(newRecordKey, newRecordFloatValue, newRecordEncrypted);
}
if (newRecord.Save())
{
allRecords.Add(newRecord);
ApplySorting();
CloseNewRecordPanel();
}
}
}
if (GUILayout.Button("Cancel", GUITools.CompactButton, GUILayout.Width(60)))
{
CloseNewRecordPanel();
}
}
}
using (GUITools.Vertical(GUITools.PanelWithBackground))
{
GUILayout.Space(5);
DrawRecordsPages();
GUILayout.Space(5);
GUI.enabled = filteredRecords.Count > 0;
using (GUITools.Horizontal())
{
if (GUILayout.Button("Encrypt ALL", GUITools.CompactButton))
{
if (EditorUtility.DisplayDialog("Obscure ALL prefs in list?", "This will apply obscuration to ALL unobscured prefs in the list.\nAre you sure you wish to do this?", "Yep", "Oh, no!"))
{
foreach (var record in filteredRecords)
{
record.Encrypt();
}
GUIUtility.keyboardControl = 0;
ApplySorting();
}
}
if (GUILayout.Button("Decrypt ALL", GUITools.CompactButton))
{
if (EditorUtility.DisplayDialog("UnObscure ALL prefs in list?", "This will remove obscuration from ALL obscured prefs in the list if possible.\nAre you sure you wish to do this?", "Yep", "Oh, no!"))
{
foreach (var record in filteredRecords)
{
record.Decrypt();
}
GUIUtility.keyboardControl = 0;
ApplySorting();
}
}
if (GUILayout.Button("Save ALL", GUITools.CompactButton))
{
if (EditorUtility.DisplayDialog("Save changes to ALL prefs in list?", "Are you sure you wish to save changes to ALL prefs in the list? This can't be undone!", "Yep", "Oh, no!"))
{
foreach (var record in filteredRecords)
{
record.Save();
}
GUIUtility.keyboardControl = 0;
ApplySorting();
}
}
if (GUILayout.Button("Delete ALL", GUITools.CompactButton))
{
if (EditorUtility.DisplayDialog("Delete ALL prefs in list?", "Are you sure you wish to delete the ALL prefs in the list? This can't be undone!", "Yep", "Oh, no!"))
{
foreach (var record in filteredRecords)
{
record.Delete();
}
RefreshData();
GUIUtility.keyboardControl = 0;
}
}
}
GUI.enabled = true;
}
}
