VRCSDK3-Editor.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using UnityEditor;
using UnityEditor.AnimatedValues;
using UnityEditor.AssetImporters;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEditor.SceneManagement;
using UnityEditor.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.UIElements;
using VRC.Core;
using VRC.SDK3.Components;
using VRC.SDK3.Editor.Exceptions;
using VRC.SDK3.Editor.VisualElements;
using VRC.SDKBase;
using VRC.SDKBase.Editor;
using VRC.SDKBase.Editor.Attributes;
using VRC.SDKBase.Editor.BuildPipeline;
using VRC.SDKBase.Validation;
 
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: VRCAssetExporter(/*Could not decode attribute arguments.*/)]
[assembly: VRCSdkBuilder(/*Could not decode attribute arguments.*/)]
[assembly: InternalsVisibleTo("VRC.SDK3.Editor")]
[assembly: UnityAPICompatibilityVersion("2022.3.22f1", true)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("VRCSDK3-Editor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+77370df7b4055abf7cc0fb1da3c3d290108e9941")]
[assembly: AssemblyProduct("VRCSDK3-Editor")]
[assembly: AssemblyTitle("VRCSDK3-Editor")]
[assembly: AssemblyVersion("1.0.0.0")]
public class ConfigureScenePlayerPersistence : Object, IVRCSDKPreprocessSceneCallback, IVRCSDKOrderedCallback, IOrderedCallback, IVRCSDKPostprocessSceneCallback
{
    private static List<string> _playerObjectsToEnableInPost;
 
    public int callbackOrder => -1024;
 
    public bool OnPreprocessScene(Scene scene)
    {
        VRCSceneDescriptor vRCSceneDescriptor = null;
        GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
        for (int i = 0; i < rootGameObjects.Length; i++)
        {
            vRCSceneDescriptor = rootGameObjects[i].GetComponentInChildren<VRCSceneDescriptor>(true);
            if ((Object)(object)vRCSceneDescriptor != (Object)null)
            {
                break;
            }
        }
        if ((Object)(object)vRCSceneDescriptor == (Object)null)
        {
            return true;
        }
        List<VRCPlayerObject> val = new List<VRCPlayerObject>();
        _playerObjectsToEnableInPost = new List<string>();
        rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
        for (int i = 0; i < rootGameObjects.Length; i++)
        {
            VRCPlayerObject[] componentsInChildren = rootGameObjects[i].GetComponentsInChildren<VRCPlayerObject>(true);
            foreach (VRCPlayerObject vRCPlayerObject in componentsInChildren)
            {
                if (((Component)vRCPlayerObject).gameObject.activeInHierarchy)
                {
                    _playerObjectsToEnableInPost.Add(((Object)vRCPlayerObject).name);
                }
                ((Component)vRCPlayerObject).gameObject.SetActive(false);
                val.Add(vRCPlayerObject);
            }
        }
        if (val.Count > 0)
        {
            vRCSceneDescriptor.PlayerPersistence = val.ToArray();
            AssetDatabase.SaveAssets();
        }
        return true;
    }
 
    public void OnPostprocessScene(Scene scene)
    {
        //IL_0067: Unknown result type (might be due to invalid IL or missing references)
        if (_playerObjectsToEnableInPost == null || _playerObjectsToEnableInPost.Count <= 0)
        {
            return;
        }
        GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
        for (int i = 0; i < rootGameObjects.Length; i++)
        {
            VRCPlayerObject[] componentsInChildren = rootGameObjects[i].GetComponentsInChildren<VRCPlayerObject>(true);
            foreach (VRCPlayerObject vRCPlayerObject in componentsInChildren)
            {
                if (_playerObjectsToEnableInPost.Contains(((Object)vRCPlayerObject).name))
                {
                    ((Component)vRCPlayerObject).gameObject.SetActive(true);
                }
            }
        }
        EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
        EditorSceneManager.SaveOpenScenes();
    }
}
namespace VRC.SDK3.Components.Editor
{
    [CanEditMultipleObjects]
    [CustomEditor(/*Could not decode attribute arguments.*/)]
    public class InputFieldEditor : SelectableEditor
    {
        private SerializedProperty m_TextComponent;
 
        private SerializedProperty m_Text;
 
        private SerializedProperty m_ContentType;
 
        private SerializedProperty m_LineType;
 
        private SerializedProperty m_InputType;
 
        private SerializedProperty m_CharacterValidation;
 
        private SerializedProperty m_KeyboardType;
 
        private SerializedProperty m_CharacterLimit;
 
        private SerializedProperty m_CaretBlinkRate;
 
        private SerializedProperty m_CaretWidth;
 
        private SerializedProperty m_CaretColor;
 
        private SerializedProperty m_CustomCaretColor;
 
        private SerializedProperty m_SelectionColor;
 
        private SerializedProperty m_HideMobileInput;
 
        private SerializedProperty m_Placeholder;
 
        private SerializedProperty m_OnValueChanged;
 
        private SerializedProperty m_OnEndEdit;
 
        private SerializedProperty m_ReadOnly;
 
        private AnimBool m_CustomColor;
 
        protected override void OnEnable()
        {
            //IL_019e: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a8: Expected O, but got Unknown
            //IL_01bb: Unknown result type (might be due to invalid IL or missing references)
            //IL_01c5: Expected O, but got Unknown
            ((SelectableEditor)this).OnEnable();
            m_TextComponent = ((Editor)this).serializedObject.FindProperty("m_TextComponent");
            m_Text = ((Editor)this).serializedObject.FindProperty("m_Text");
            m_ContentType = ((Editor)this).serializedObject.FindProperty("m_ContentType");
            m_LineType = ((Editor)this).serializedObject.FindProperty("m_LineType");
            m_InputType = ((Editor)this).serializedObject.FindProperty("m_InputType");
            m_CharacterValidation = ((Editor)this).serializedObject.FindProperty("m_CharacterValidation");
            m_KeyboardType = ((Editor)this).serializedObject.FindProperty("m_KeyboardType");
            m_CharacterLimit = ((Editor)this).serializedObject.FindProperty("m_CharacterLimit");
            m_CaretBlinkRate = ((Editor)this).serializedObject.FindProperty("m_CaretBlinkRate");
            m_CaretWidth = ((Editor)this).serializedObject.FindProperty("m_CaretWidth");
            m_CaretColor = ((Editor)this).serializedObject.FindProperty("m_CaretColor");
            m_CustomCaretColor = ((Editor)this).serializedObject.FindProperty("m_CustomCaretColor");
            m_SelectionColor = ((Editor)this).serializedObject.FindProperty("m_SelectionColor");
            m_HideMobileInput = ((Editor)this).serializedObject.FindProperty("m_HideMobileInput");
            m_Placeholder = ((Editor)this).serializedObject.FindProperty("m_Placeholder");
            m_OnValueChanged = ((Editor)this).serializedObject.FindProperty("m_OnValueChanged");
            m_OnEndEdit = ((Editor)this).serializedObject.FindProperty("m_OnEndEdit");
            m_ReadOnly = ((Editor)this).serializedObject.FindProperty("m_ReadOnly");
            m_CustomColor = new AnimBool(m_CustomCaretColor.boolValue);
            ((BaseAnimValue<bool>)(object)m_CustomColor).valueChanged.AddListener(new UnityAction(((Editor)this).Repaint));
        }
 
        protected override void OnDisable()
        {
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_0023: Expected O, but got Unknown
            ((SelectableEditor)this).OnDisable();
            ((BaseAnimValue<bool>)(object)m_CustomColor).valueChanged.RemoveListener(new UnityAction(((Editor)this).Repaint));
        }
 
        public override void OnInspectorGUI()
        {
            ((Editor)this).serializedObject.Update();
            ((SelectableEditor)this).OnInspectorGUI();
            EditorGUILayout.Space();
            EditorGUILayout.PropertyField(m_TextComponent, Array.Empty<GUILayoutOption>());
            if (m_TextComponent != null && m_TextComponent.objectReferenceValue != (Object)null && ((Text)/*isinst with value type is only supported in some contexts*/).supportRichText)
            {
                EditorGUILayout.HelpBox("Using Rich Text with input is unsupported.", (MessageType)2);
            }
            DisabledScope val = default(DisabledScope);
            ((DisabledScope)(ref val))..ctor(m_TextComponent == null || m_TextComponent.objectReferenceValue == (Object)null);
            try
            {
                EditorGUILayout.PropertyField(m_Text, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_CharacterLimit, Array.Empty<GUILayoutOption>());
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(m_ContentType, Array.Empty<GUILayoutOption>());
                if (!m_ContentType.hasMultipleDifferentValues)
                {
                    EditorGUI.indentLevel += 1;
                    if (m_ContentType.enumValueIndex == 0 || m_ContentType.enumValueIndex == 1 || m_ContentType.enumValueIndex == 9)
                    {
                        EditorGUILayout.PropertyField(m_LineType, Array.Empty<GUILayoutOption>());
                    }
                    if (m_ContentType.enumValueIndex == 9)
                    {
                        EditorGUILayout.PropertyField(m_InputType, Array.Empty<GUILayoutOption>());
                        EditorGUILayout.PropertyField(m_KeyboardType, Array.Empty<GUILayoutOption>());
                        EditorGUILayout.PropertyField(m_CharacterValidation, Array.Empty<GUILayoutOption>());
                    }
                    EditorGUI.indentLevel -= 1;
                }
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(m_Placeholder, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_CaretBlinkRate, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_CaretWidth, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_CustomCaretColor, Array.Empty<GUILayoutOption>());
                ((BaseAnimValue<bool>)(object)m_CustomColor).target = m_CustomCaretColor.boolValue;
                if (EditorGUILayout.BeginFadeGroup(m_CustomColor.faded))
                {
                    EditorGUILayout.PropertyField(m_CaretColor, Array.Empty<GUILayoutOption>());
                }
                EditorGUILayout.EndFadeGroup();
                EditorGUILayout.PropertyField(m_SelectionColor, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_HideMobileInput, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_ReadOnly, Array.Empty<GUILayoutOption>());
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(m_OnValueChanged, Array.Empty<GUILayoutOption>());
                EditorGUILayout.PropertyField(m_OnEndEdit, Array.Empty<GUILayoutOption>());
            }
            finally
            {
                ((IDisposable)(DisabledScope)(ref val)).Dispose();
            }
            ((Editor)this).serializedObject.ApplyModifiedProperties();
        }
    }
}
namespace VRC.SDK3.Midi
{
    [ScriptedImporter(1, "mid")]
    public class MidiFileImporter : ScriptedImporter
    {
        public MidiImportSettings ImportSettings = new MidiImportSettings();
 
        public override void OnImportAsset(AssetImportContext ctx)
        {
            MidiFile midiFile = MidiFile.Create(ctx.assetPath, ImportSettings);
            ctx.AddObjectToAsset("main obj", (Object)(object)midiFile);
            ctx.SetMainObject((Object)(object)midiFile);
        }
    }
}
namespace VRC.SDK3.Editor
{
    [CustomPropertyDrawer(/*Could not decode attribute arguments.*/)]
    public class EnumFlagsAttributeDrawer : PropertyDrawer
    {
        public override void OnGUI(Rect _position, SerializedProperty _property, GUIContent _label)
        {
            //IL_003d: Unknown result type (might be due to invalid IL or missing references)
            //IL_009a: Unknown result type (might be due to invalid IL or missing references)
            int num = 0;
            int num2 = _property.enumNames.Length;
            bool[] array = (bool[])(object)new Boolean[num2];
            float num3 = (((Rect)(ref _position)).width - EditorGUIUtility.labelWidth) / (float)num2;
            EditorGUI.LabelField(new Rect(((Rect)(ref _position)).x, ((Rect)(ref _position)).y, EditorGUIUtility.labelWidth, ((Rect)(ref _position)).height), _label);
            EditorGUI.BeginChangeCheck();
            Rect val = default(Rect);
            for (int i = 0; i < num2; i++)
            {
                if ((_property.intValue & (1 << i)) == 1 << i)
                {
                    array[i] = true;
                }
                ((Rect)(ref val))..ctor(((Rect)(ref _position)).x + EditorGUIUtility.labelWidth + num3 * (float)i, ((Rect)(ref _position)).y, num3, ((Rect)(ref _position)).height);
                array[i] = GUI.Toggle(val, array[i], _property.enumNames[i], GUIStyle.op_Implicit("Button"));
                if (array[i])
                {
                    num += 1 << i;
                }
            }
            if (EditorGUI.EndChangeCheck())
            {
                _property.intValue = num;
            }
        }
    }
    [CustomEditor(/*Could not decode attribute arguments.*/)]
    public class VRCEnablePersistenceEditor : Editor
    {
        public override VisualElement CreateInspectorGUI()
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0035: Unknown result type (might be due to invalid IL or missing references)
            //IL_003d: Expected O, but got Unknown
            VisualElement val = new VisualElement();
            HelpBoxVisualElement helpBoxVisualElement = new HelpBoxVisualElement("Persistence will be enabled for this object, and all of its children.", (HelpBoxMessageType)1);
            if (!Object.op_Implicit((Object)(object)((Component)(((Editor)this).target as VRCEnablePersistence)).GetComponentInParent<VRCPlayerObject>(true)))
            {
                helpBoxVisualElement = new HelpBoxVisualElement("VRCEnablePersistence must be a child of a VRCPlayerObject to enable persistence.", (HelpBoxMessageType)3);
            }
            val.Add((VisualElement)(object)helpBoxVisualElement);
            return val;
        }
    }
}
namespace VRC.SDK3.Editor.VisualElements
{
    public class HelpBoxVisualElement : HelpBox
    {
        public HelpBoxVisualElement(string message, HelpBoxMessageType messageType)
            : base(message, messageType)
        {
            //IL_0002: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_002b: Unknown result type (might be due to invalid IL or missing references)
            Label obj = UQueryExtensions.Q<Label>((VisualElement)(object)this, (string)null, (string)null);
            ((VisualElement)obj).style.whiteSpace = StyleEnum<WhiteSpace>.op_Implicit((WhiteSpace)0);
            ((VisualElement)obj).style.fontSize = StyleLength.op_Implicit(12f);
        }
    }
}
namespace VRC.SDK3.Editor.Players
{
    [CustomEditor(/*Could not decode attribute arguments.*/)]
    public class VRCPlayerPersistenceEditor : Editor
    {
        private void OnEnable()
        {
            //IL_0007: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Expected O, but got Unknown
            EditorApplication.hierarchyChanged += new Action(RemoveNestedPlayerObjectComponents);
            RemoveNestedPlayerObjectComponents();
        }
 
        private void OnDisable()
        {
            //IL_0007: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Expected O, but got Unknown
            EditorApplication.hierarchyChanged -= new Action(RemoveNestedPlayerObjectComponents);
        }
 
        private void RemoveNestedPlayerObjectComponents()
        {
            VRCPlayerObject vRCPlayerObject = (VRCPlayerObject)(object)((Editor)this).target;
            if (!((Object)(object)vRCPlayerObject == (Object)null))
            {
                string existingPlayerObjectChild;
                if (HasParentWithComponent(((Component)vRCPlayerObject).transform, out var existingPlayerObjectParent))
                {
                    Debug.LogError((object)String.Concat((string[])(object)new String[5]
                    {
                        "Can't add VRCPlayerObject to ",
                        ((Editor)this).target.name,
                        ". Parent ",
                        existingPlayerObjectParent,
                        " already has a VRCPlayerObject component. Nested VRCPlayerObject components are not supported."
                    }));
                    Object.DestroyImmediate((Object)(object)vRCPlayerObject);
                }
                else if (HasChildWithComponent(((Component)vRCPlayerObject).transform, out existingPlayerObjectChild))
                {
                    Debug.LogError((object)String.Concat((string[])(object)new String[5]
                    {
                        "Can't add VRCPlayerObject to ",
                        ((Editor)this).target.name,
                        ". Child ",
                        existingPlayerObjectChild,
                        " already has a VRCPlayerObject component. Nested VRCPlayerObject components are not supported."
                    }));
                    Object.DestroyImmediate((Object)(object)vRCPlayerObject);
                }
            }
        }
 
        private static bool HasParentWithComponent(Transform target, out string existingPlayerObjectParent)
        {
            Transform parent = target.parent;
            VRCPlayerObject vRCPlayerObject = default(VRCPlayerObject);
            while ((Object)(object)parent != (Object)null)
            {
                if (((Component)parent).TryGetComponent<VRCPlayerObject>(ref vRCPlayerObject))
                {
                    existingPlayerObjectParent = ((Object)parent).name;
                    return true;
                }
                parent = parent.parent;
            }
            existingPlayerObjectParent = String.Empty;
            return false;
        }
 
        private static bool HasChildWithComponent(Transform target, out string existingPlayerObjectChild)
        {
            //IL_0014: Unknown result type (might be due to invalid IL or missing references)
            //IL_001a: Expected O, but got Unknown
            IEnumerator enumerator = ((Component)target).transform.GetEnumerator();
            try
            {
                VRCPlayerObject vRCPlayerObject = default(VRCPlayerObject);
                while (enumerator.MoveNext())
                {
                    Transform val = (Transform)enumerator.Current;
                    if (((Component)val).TryGetComponent<VRCPlayerObject>(ref vRCPlayerObject))
                    {
                        existingPlayerObjectChild = ((Object)val).name;
                        return true;
                    }
                    if (HasChildWithComponent(val, out existingPlayerObjectChild))
                    {
                        return true;
                    }
                }
            }
            finally
            {
                IDisposable val2 = (IDisposable)(object)((enumerator is IDisposable) ? enumerator : null);
                if (val2 != null)
                {
                    val2.Dispose();
                }
            }
            existingPlayerObjectChild = String.Empty;
            return false;
        }
 
        public override VisualElement CreateInspectorGUI()
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Expected O, but got Unknown
            VisualElement val = new VisualElement();
            HelpBoxVisualElement helpBoxVisualElement = new HelpBoxVisualElement("Player Objects are automatically instantiated once for each player that joins, providing each player with their own copy of that GameObject, its UdonBehaviours, other components, and children. This object will be the template, and should not be modified or referenced after the world has loaded. Use Networking.GetPlayerObjects to get the player objects associated with a player instead.", (HelpBoxMessageType)1);
            val.Add((VisualElement)(object)helpBoxVisualElement);
            return val;
        }
    }
}
namespace VRC.SDK3.Editor.Exceptions
{
    public class WorldAssetExportException : Exception
    {
        public WorldAssetExportException(string message)
            : base(message)
        {
        }
 
        public WorldAssetExportException(string message, Exception innerException)
            : base(message, innerException)
        {
        }
    }
    public class AdbException : Exception
    {
        public int exitCode;
 
        public string standardOutput;
 
        public string standardError;
 
        public AdbException(int exitCode, string stdOut, string stdError)
            : base(String.Format("ADB failed with exit code {0}.\nStdOut:{1}\nStdError:{2}", (object)exitCode, (object)stdOut, (object)stdError))
        {
            this.exitCode = exitCode;
            standardOutput = stdOut;
            standardError = stdError;
        }
    }
    public class AndroidTestBuildException : Exception
    {
        public AndroidTestBuildException(string message)
            : base(message)
        {
        }
 
        public AndroidTestBuildException(string message, Exception innerException)
            : base(message, innerException)
        {
        }
    }
}
namespace VRC.SDK3.Editor.Builder
{
    public class VRCWorldAssetExporter : Object, IAssetExporter, IProcessSceneWithReport, IOrderedCallback
    {
        [CompilerGenerated]
        private sealed class <>c__DisplayClass4_0 : Object
        {
            public List<GameObject> prefabs;
 
            internal bool <FindDynamicContent>b__0(GameObject p)
            {
                return !prefabs.Contains(p);
            }
        }
 
        public string Name => "VRCAvatarAssetExporter";
 
        int IOrderedCallback.callbackOrder => 2147475455;
 
        public void ExportCurrentSceneResource()
        {
            ExportCurrentSceneResource(buildAssetBundle: true, null, null);
        }
 
        public void ExportCurrentSceneResource(bool buildAssetBundle = true, Action<string> onProgress = null, Action<object> onContentProcessed = null)
        {
            //IL_03f7: Expected O, but got Unknown
            //IL_000c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0011: Unknown result type (might be due to invalid IL or missing references)
            //IL_00bd: Unknown result type (might be due to invalid IL or missing references)
            //IL_00c2: Unknown result type (might be due to invalid IL or missing references)
            //IL_00e9: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ee: Unknown result type (might be due to invalid IL or missing references)
            //IL_00fb: Unknown result type (might be due to invalid IL or missing references)
            //IL_0102: Unknown result type (might be due to invalid IL or missing references)
            //IL_00f2: Unknown result type (might be due to invalid IL or missing references)
            //IL_010d: Unknown result type (might be due to invalid IL or missing references)
            //IL_0184: Unknown result type (might be due to invalid IL or missing references)
            //IL_0189: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a3: Unknown result type (might be due to invalid IL or missing references)
            //IL_01a8: Unknown result type (might be due to invalid IL or missing references)
            //IL_0235: Unknown result type (might be due to invalid IL or missing references)
            //IL_023a: Unknown result type (might be due to invalid IL or missing references)
            //IL_023c: Unknown result type (might be due to invalid IL or missing references)
            //IL_025e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0263: Unknown result type (might be due to invalid IL or missing references)
            //IL_0245: Unknown result type (might be due to invalid IL or missing references)
            //IL_0251: Unknown result type (might be due to invalid IL or missing references)
            //IL_0291: Unknown result type (might be due to invalid IL or missing references)
            //IL_02b2: Unknown result type (might be due to invalid IL or missing references)
            //IL_02b4: Unknown result type (might be due to invalid IL or missing references)
            //IL_02b9: Unknown result type (might be due to invalid IL or missing references)
            //IL_02be: Unknown result type (might be due to invalid IL or missing references)
            //IL_02c0: Unknown result type (might be due to invalid IL or missing references)
            //IL_02c5: Unknown result type (might be due to invalid IL or missing references)
            //IL_02de: Unknown result type (might be due to invalid IL or missing references)
            //IL_037e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0383: Unknown result type (might be due to invalid IL or missing references)
            //IL_039d: Unknown result type (might be due to invalid IL or missing references)
            //IL_039f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0416: Unknown result type (might be due to invalid IL or missing references)
            Scene activeScene;
            string text;
            if (!EditorPrefs.HasKey("originalScenePath"))
            {
                activeScene = SceneManager.GetActiveScene();
                text = ((Scene)(ref activeScene)).path;
            }
            else
            {
                text = EditorPrefs.GetString("originalScenePath");
            }
            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
            onProgress?.Invoke("Validating Scene");
            VRCSceneDescriptor[] array = Tools.FindSceneObjectsOfTypeAll<VRCSceneDescriptor>();
            if (array == null || array.Length != 1)
            {
                EditorUtility.DisplayDialog("Build Custom Scene", "Scene needs exactly one VRC_SceneDescriptor", "Ok");
                return;
            }
            VRCSceneDescriptor vRCSceneDescriptor = array[0];
            if ((Object)(object)vRCSceneDescriptor == (Object)null)
            {
                EditorUtility.DisplayDialog("Build Custom Scene", "You must place a VRC_SceneDescriptor on the root of you custom scene", "Ok");
                return;
            }
            if (((VRC_SceneDescriptor)vRCSceneDescriptor).spawns.Length < 1)
            {
                EditorUtility.DisplayDialog("Build Custom Scene", "You must add at least one spawn to spawns in your VRC_SceneDescriptor.", "Ok");
                return;
            }
            onProgress?.Invoke("Preparing Scene");
            AssetExporter.DoPreExportShaderReplacement();
            FindDynamicContent((VRC_SceneDescriptor)(object)vRCSceneDescriptor);
            ((VRC_SceneDescriptor)vRCSceneDescriptor).gravity = Physics.gravity;
            ((VRC_SceneDescriptor)vRCSceneDescriptor).layerCollisionArr = UpdateLayers.GetLayerCollisionArray();
            ((VRC_SceneDescriptor)vRCSceneDescriptor).unityVersion = Application.unityVersion;
            EditorUtility.SetDirty((Object)(object)vRCSceneDescriptor);
            Scene scene = ((Component)vRCSceneDescriptor).gameObject.scene;
            if (buildAssetBundle && !VRCBuildPipelineCallbacks.OnPreprocessScene(scene))
            {
                return;
            }
            EditorSceneManager.MarkSceneDirty(scene);
            EditorSceneManager.SaveScene(scene);
            onContentProcessed?.Invoke((object)scene);
            if (!buildAssetBundle)
            {
                onProgress?.Invoke("Skipping AssetBundle, Build Complete");
                return;
            }
            try
            {
                string text2 = ((Scene)(ref scene)).path;
                onProgress?.Invoke("Exporting Scene");
                bool flag = false;
                if (fileNameWithoutExtension.Contains("."))
                {
                    flag = true;
                    string text3 = "Assets/customTmpScene12345.unity";
                    AssetDatabase.CopyAsset(text2, text3);
                    text2 = text3;
                    AssetDatabase.Refresh();
                }
                AssetDatabase.RemoveUnusedAssetBundleNames();
                String[] obj = new String[5]
                {
                    "scene-",
                    default(String),
                    default(String),
                    default(String),
                    default(String)
                };
                BuildTarget activeBuildTarget = EditorUserBuildSettings.activeBuildTarget;
                obj[1] = ((Object)(BuildTarget)(ref activeBuildTarget)).ToString();
                obj[2] = "-";
                activeScene = SceneManager.GetActiveScene();
                obj[3] = ((Scene)(ref activeScene)).name;
                obj[4] = ".vrcw";
                string text4 = String.Concat((string[])(object)obj);
                string text5 = String.Concat(Application.temporaryCachePath, "/", text4);
                string localLowPath = VRC_SdkBuilder.GetLocalLowPath();
                string text6;
                if (!String.IsNullOrEmpty(localLowPath))
                {
                    text6 = Path.Combine((string[])(object)new String[5] { localLowPath, "VRChat", "VRChat", "Worlds", text4 });
                    string directoryName = Path.GetDirectoryName(text6);
                    if (!String.IsNullOrEmpty(directoryName))
                    {
                        Directory.CreateDirectory(directoryName);
                    }
                }
                else
                {
                    text6 = text5;
                }
                Keypair val = default(Keypair);
                LibResult val2 = VRCFastCrypto.GenerateSigningKey(ref val);
                if ((int)val2 != 0)
                {
                    throw new Exception(String.Format("Failed to generate signing key: {0}", (object)val2));
                }
                SigningKey signingKey = ((Keypair)(ref val)).SigningKey;
                EditorPrefs.SetString("currentBuildingAssetBundleCodeSigningKey", Convert.ToBase64String(((SigningKey)(ref signingKey)).Key));
                onProgress?.Invoke("Creating an Asset Bundle");
                AssetBundleBuild[] array2 = (AssetBundleBuild[])(object)new AssetBundleBuild[1]
                {
                    new AssetBundleBuild
                    {
                        assetNames = (string[])(object)new String[1] { text2 },
                        assetBundleName = text4
                    }
                };
                BuildTarget activeBuildTarget2 = EditorUserBuildSettings.activeBuildTarget;
                BuildTargetGroup selectedBuildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
                onProgress?.Invoke("Building the Asset Bundle");
                BuildPipeline.BuildAssetBundles(Application.temporaryCachePath, array2, (BuildAssetBundleOptions)32, EditorUserBuildSettings.activeBuildTarget);
                if (!File.Exists(text5))
                {
                    Logger.LogError("AssetBundle was not built", (DebugLevel)0, (Object)null);
                    return;
                }
                onProgress?.Invoke("Bundle Built, Processing Bundle");
                uint num = default(uint);
                if (!BuildPipeline.GetCRCForAssetBundle(text5, ref num))
                {
                    Logger.LogError("Failed to get CRC for asset bundle!", (DebugLevel)0, (Object)null);
                    num = 0u;
                }
                List<byte> obj2 = new List<byte>();
                obj2.Add((byte)0);
                obj2.Add((byte)(num & 0xFFu));
                obj2.Add((byte)((num >> 8) & 0xFFu));
                obj2.Add((byte)((num >> 16) & 0xFFu));
                obj2.Add((byte)((num >> 24) & 0xFFu));
                VerifyKey verifyKey = ((Keypair)(ref val)).VerifyKey;
                obj2.AddRange((IEnumerable<byte>)(object)((VerifyKey)(ref verifyKey)).Key);
                string text7 = Convert.ToBase64String(obj2.ToArray());
                EditorUserBuildSettings.SwitchActiveBuildTarget(selectedBuildTargetGroup, activeBuildTarget2);
                if (text5 != text6)
                {
                    File.Copy(text5, text6, true);
                    File.Delete(text5);
                }
                EditorPrefs.SetString("currentBuildingAssetBundlePath", text6);
                EditorPrefs.SetString("currentBuildingAssetBundleWorldSignature", text7);
                EditorPrefs.SetString("lastVRCPath", text6);
                if (flag)
                {
                    AssetDatabase.DeleteAsset(text2);
                }
            }
            catch (Exception val3)
            {
                Exception val4 = val3;
                Debug.LogError((object)String.Concat("Export Exception - ", (val4 != null) ? ((Object)val4).ToString() : null));
                throw;
            }
            VRCBuildPipelineCallbacks.OnPostprocessScene(scene);
            onProgress?.Invoke("Build Complete");
        }
 
        private static void FindDynamicContent(VRC_SceneDescriptor desc)
        {
            <>c__DisplayClass4_0 CS$<>8__locals0 = new <>c__DisplayClass4_0();
            CS$<>8__locals0.prefabs = new List<GameObject>();
            List<Material> val = new List<Material>();
            AssetExporter.FindDynamicContent(ref CS$<>8__locals0.prefabs, ref val);
            desc.DynamicMaterials = val;
            if (desc.DynamicPrefabs != null && desc.DynamicPrefabs.Count > 0)
            {
                CS$<>8__locals0.prefabs.AddRange(Enumerable.Where<GameObject>((IEnumerable<GameObject>)(object)desc.DynamicPrefabs, (Func<GameObject, bool>)((GameObject p) => !CS$<>8__locals0.prefabs.Contains(p))));
            }
            desc.DynamicPrefabs = CS$<>8__locals0.prefabs;
            String[] obj = new String[5]
            {
                "Found ",
                default(String),
                default(String),
                default(String),
                default(String)
            };
            int count = CS$<>8__locals0.prefabs.Count;
            obj[1] = ((Int32)(ref count)).ToString();
            obj[2] = " prefabs and ";
            count = val.Count;
            obj[3] = ((Int32)(ref count)).ToString();
            obj[4] = " materials";
            Logger.Log(String.Concat((string[])(object)obj), (DebugLevel)9, (Object)null);
        }
 
        public void FinishExportCurrentSceneResourceWithPlugin()
        {
            //IL_0009: Expected O, but got Unknown
            try
            {
                ExportCurrentSceneResource();
            }
            catch (Exception val)
            {
                Exception val2 = val;
                Debug.LogError((object)String.Concat((val2 != null) ? ((Object)val2).ToString() : null, "\n", val2.StackTrace));
                throw;
            }
        }
 
        public static void RunScene(string bundleFilePath, string pluginFilePath)
        {
            if (Tools.Platform == "android")
            {
                try
                {
                    RunWorldTestAndroid(bundleFilePath);
                    return;
                }
                catch (AdbException innerException)
                {
                    throw new WorldAssetExportException("An ADB command failed to execute.\nCheck the console for more details.", (Exception)(object)innerException);
                }
            }
            RunWorldTestDesktop(bundleFilePath, pluginFilePath);
        }
 
        private static void RunWorldTestDesktop(string bundleFilePath, string pluginFilePath)
        {
            //IL_00e4: Unknown result type (might be due to invalid IL or missing references)
            //IL_00e9: Unknown result type (might be due to invalid IL or missing references)
            //IL_0100: Expected O, but got Unknown
            string text = UnityWebRequest.EscapeURL(bundleFilePath).Replace("+", "%20");
            string text2 = UnityWebRequest.EscapeURL(pluginFilePath).Replace("+", "%20");
            string randomDigits = Tools.GetRandomDigits(10);
            string text3 = SDKClientUtilities.GetSavedVRCInstallPath();
            if (String.IsNullOrEmpty(text3) || !File.Exists(text3))
            {
                text3 = String.Concat("vrchat://create?roomId=", randomDigits, "&hidden=true&name=BuildAndRun&url=file:///", text);
                if (!String.IsNullOrEmpty(text2))
                {
                    text3 = String.Concat(text3, "&pluginUrl=file:///", text2);
                }
            }
            string text4 = String.Concat("--url=create?roomId=", randomDigits, "&hidden=true&name=BuildAndRun&url=file:///", text);
            if (!String.IsNullOrEmpty(text2))
            {
                text4 = String.Concat(text4, "&pluginUrl=file:///", text2);
            }
            string text5 = (VRCSettings.ForceNoVR ? " --no-vr" : "");
            string text6 = (VRCSettings.WatchWorlds ? " --watch-worlds" : "");
            string text7 = String.Concat("--enable-debug-gui --enable-sdk-log-levels --enable-udon-debug-logging ", text5, text6);
            ProcessStartInfo val = new ProcessStartInfo(text3, String.Concat(text4, " ", text7))
            {
                WorkingDirectory = (Path.GetDirectoryName(text3) ?? "")
            };
            for (int i = 0; i < VRCSettings.NumClients; i++)
            {
                Process.Start(val);
                Thread.Sleep(3000);
            }
        }
 
        private static void RunWorldTestAndroid(string bundleFilePath)
        {
            //IL_0119: Unknown result type (might be due to invalid IL or missing references)
            //IL_0120: Expected O, but got Unknown
            //IL_00c5: Unknown result type (might be due to invalid IL or missing references)
            //IL_00ca: Unknown result type (might be due to invalid IL or missing references)
            List<string> androidDevices = GetAndroidDevices();
            if (androidDevices.Count < 1)
            {
                throw new WorldAssetExportException("No android devices with ADB debugging enabled have been found.\nPlease plug in the device and enable USB debugging in the \"System\"->\"Developer Options\" settings section.\nNote that the \"System\"->\"Developer Options\" section only appears if you've enabled developer mode in Android, which you can enable by tapping \"About Phone\"->\"Build Number\" 7 times\n\nIf your device is still not appearing after trying the above, please try the following:\n1. Unplug the Android device\n2. Disable developer mode and USB debugging\n3. Plug in the Android device\n4. Enable developer mode by tapping \"About Phone\"->\"Build Number\" 7 times\n5. Enable USB debugging in the \"System\"->\"Developer Options\" section\n6. Attempt to Build and Test again.");
            }
            if (androidDevices.Count > 1)
            {
                throw new WorldAssetExportException(String.Concat("Multiple devices with ADB debugging enabled have been found. Unplug or disable USB debugging until the one device you would like to test on remains.\nCurrently available devices:\n", String.Join("\n", (IEnumerable<string>)(object)androidDevices)));
            }
            string text = Enumerable.First<string>((IEnumerable<string>)(object)androidDevices);
            Debug.Log((object)String.Concat("Testing on ADB device ", text));
            string text2 = null;
            bool flag = false;
            string text3;
            if (text.ToLower().Contains("model:quest"))
            {
                text3 = ADB.GetQuestAppDataPath();
                text2 = VRCSettings.QuestPackageName;
                flag = true;
            }
            else
            {
                text3 = ADB.GetAndroidAppDataPath();
                text2 = VRCSettings.AndroidPackageName;
            }
            switch (ADB.GetDeviceLockState())
            {
            case DeviceLockState.LOCKED:
                if (flag)
                {
                    throw new WorldAssetExportException("Failed to test Android world: Device is locked.\nYour device must remain unlocked when starting a test build.\n\nEnsure that you are logged into the Meta Quest Developer Hub and your headset is properly connected before attempting to test an Android world.");
                }
                throw new WorldAssetExportException("Failed to test Android world: Device is locked.\nYour device must remain unlocked when starting a test build.\n\nYou may find it useful to enable the \"Stay Awake\" option in \"System\"->\"Developer Options\" to prevent the phone from locking while it's plugged in and charging.");
            case DeviceLockState.UNKNOWN:
                Debug.LogWarning((object)"Unable to determine if Android device is locked.\nNote that on some devices the device must remain unlocked for the VRChat app to be launched. Leave your device unlocked if the app is not launching.");
                break;
            }
            string extension = Path.GetExtension(bundleFilePath);
            DateTime utcNow = DateTime.UtcNow;
            string text4 = String.Format("{0}_{1}", (object)((DateTime)(ref utcNow)).ToFileTimeUtc(), (object)extension).TrimStart('/');
            text3 = text3.TrimEnd('/');
            if (!ADB.AdbDirectoryExists(text3))
            {
                string[] array = Array.Empty<string>();
                try
                {
                    array = ADB.GetPotentialVRChatAppPackages();
                }
                catch (Object)
                {
                    Debug.LogWarning((object)"Unable to find potential VRChat app packages");
                }
                StringBuilder val2 = new StringBuilder();
                val2.AppendLine("Unable to find a valid vrchat app directory on the device. Is the VRChat app installed?");
                val2.AppendLine();
                val2.AppendLine(String.Concat("Looking for '", text3, "'."));
                if (array.Length != 0)
                {
                    string text5 = String.Join("\n", Enumerable.Select<string, string>((IEnumerable<string>)(object)array, (Func<string, string>)((string x) => String.Concat("\t", x))));
                    val2.AppendLine("Potential app package names found on device:");
                    val2.AppendLine(text5);
                }
                string text6 = "Android App Package Name";
                if (flag)
                {
                    text6 = "Quest App Package Name";
                }
                val2.AppendLine(String.Concat("Use the project setting \"VRChat\"->\"SDK\"->\"", text6, "\" to change where the SDK looks for your app."));
                if (array.Length == 1)
                {
                    val2.AppendLine(String.Concat((string[])(object)new String[5]
                    {
                        "Try changing \"VRChat\"->\"SDK\"->\"",
                        text6,
                        "\" to \"",
                        Enumerable.First<string>((IEnumerable<string>)(object)array),
                        "\""
                    }));
                }
                val2.AppendLine();
                val2.AppendLine("If you've just installed the app, launch it once before trying to build and test.");
                val2.AppendLine();
                val2.AppendLine("Note that the following Android device is being used:");
                val2.AppendLine(text);
                throw new WorldAssetExportException(((Object)val2).ToString());
            }
            AndroidCleanupOldTestWorlds(text3);
            string text7 = String.Concat(text3, "/files/TestWorlds/", text4);
            ADB.MakeDirectory(String.Concat(text3, "/files/TestWorlds"));
            ADB.PushFile(bundleFilePath, text7);
            ADB.Command("shell", "content", "call", "--method", "scan_volume", "--uri", "content://media", "--arg", "external_primary");
            ADB.Sync();
            ADB.StartVRChat(text7, text2);
            AnalyticsSDK.BuildAndTestLaunched(flag ? "Quest" : "AndroidGeneric", text);
        }
 
        private static List<string> GetAndroidDevices()
        {
            //IL_0009: Expected O, but got Unknown
            try
            {
                return ADB.GetDevices();
            }
            catch (Win32Exception val)
            {
                Win32Exception val2 = val;
                if (!((Exception)val2).Message.Contains("The system cannot find the file specified"))
                {
                    throw val2;
                }
                throw new WorldAssetExportException("Unable to locate Android Debug Bridge (adb.exe). Please be sure to install the Android SDK as a Unity module, or add adb.exe to the PATH.", (Exception)(object)val2);
            }
        }
 
        private static void AndroidCleanupOldTestWorlds(string appPath)
        {
            //IL_0057: Expected O, but got Unknown
            string text = String.Concat(appPath, "/files/TestWorlds");
            AdbResult adbResult;
            try
            {
                adbResult = ADB.Command("shell", "find", text, "-mindepth", "1", "-mtime", "+1", "-delete");
            }
            catch (Exception val)
            {
                Exception val2 = val;
                if (val2.Message.Contains("No such file or directory"))
                {
                    return;
                }
                throw new WorldAssetExportException(String.Concat("Unable to cleanup test world folder at path '", text, "'"), val2);
            }
            IEnumerator<string> enumerator = Enumerable.Select<string, string>((IEnumerable<string>)(object)adbResult.standardOut.Split("\n", (StringSplitOptions)0), (Func<string, string>)((string x) => x.Trim())).GetEnumerator();
            try
            {
                while (((IEnumerator)enumerator).MoveNext())
                {
                    string current = enumerator.Current;
                    if (!String.IsNullOrWhiteSpace(current) && !String.IsNullOrEmpty(current))
                    {
                        Debug.Log((object)String.Concat("Deleted old test world file ", current, " on remote device"));
                    }
                }
            }
            finally
            {
                if (enumerator != null)
                {
                    ((IDisposable)enumerator).Dispose();
                }
            }
        }
 
        [Obsolete("Use methods from VRC.SDKBase.Editor.Api.VRCApi class for uploads instead")]
        public static void LaunchSceneBlueprintUploader()
        {
            Debug.LogError((object)"Uploading via AssetExporter is no longer supported");
        }
 
        public static void RunExportedSceneResourceAndCleanupPlugin()
        {
            RunExportedSceneResource();
        }
 
        private static void RunExportedSceneResource()
        {
            string @string = EditorPrefs.GetString("currentBuildingAssetBundlePath");
            if (!String.IsNullOrEmpty(@string))
            {
                string string2 = EditorPrefs.GetString("externalPluginPath");
                EditorPrefs.DeleteKey("externalPluginPath");
                RunScene(@string, string2);
            }
        }
 
        void IProcessSceneWithReport.OnProcessScene(Scene scene, BuildReport report)
        {
            //IL_011d: Expected O, but got Unknown
            //IL_0036: Unknown result type (might be due to invalid IL or missing references)
            //IL_003b: Unknown result type (might be due to invalid IL or missing references)
            if (Application.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }
            string @string = EditorPrefs.GetString("currentBuildingAssetBundleCodeSigningKey");
            if (String.IsNullOrEmpty(@string))
            {
                Debug.LogWarning((object)"No signing key found, skipping Udon code signing");
                return;
            }
            try
            {
                SigningKey signingKey = new SigningKey(Convert.FromBase64String(@string));
                IEnumerator<UdonSignatureHolderMarker> enumerator = TypeUtils.FindAssemblyAttributes<UdonSignatureHolderMarker>().GetEnumerator();
                try
                {
                    while (((IEnumerator)enumerator).MoveNext())
                    {
                        Type type = enumerator.Current.type;
                        if (!type.IsSubclassOf(typeof(ScriptableObject)))
                        {
                            continue;
                        }
                        Stopwatch val = Stopwatch.StartNew();
                        Object[] array = Resources.FindObjectsOfTypeAll(type);
                        Object[] array2 = array;
                        foreach (Object val2 in array2)
                        {
                            if (!(val2 == (Object)null) && val2 is IUdonSignatureHolder udonSignatureHolder)
                            {
                                udonSignatureHolder.EnsureGZipFormat();
                                udonSignatureHolder.Signature = Sign(udonSignatureHolder.SignedData);
                                EditorUtility.SetDirty(val2);
                            }
                        }
                        Debug.Log((object)String.Format("Computed code signatures for {0} scripts of type {1} in {2}ms", (object)array.Length, (object)((MemberInfo)type).Name, (object)val.ElapsedMilliseconds));
                    }
                }
                finally
                {
                    if (enumerator != null)
                    {
                        ((IDisposable)enumerator).Dispose();
                    }
                }
                [CompilerGenerated]
                byte[] Sign(byte[] data)
                {
                    //IL_001d: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0022: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0023: Unknown result type (might be due to invalid IL or missing references)
                    //IL_002b: Unknown result type (might be due to invalid IL or missing references)
                    //IL_0036: Unknown result type (might be due to invalid IL or missing references)
                    if (data == null || data.Length == 0)
                    {
                        Debug.LogError((object)"Cannot sign empty data");
                        return null;
                    }
                    byte[] result = default(byte[]);
                    LibResult val5 = VRCFastCrypto.SignMessage(ref signingKey, ref data, ref result);
                    if ((int)val5 != 0)
                    {
                        throw new Exception(String.Format("Failed to sign data: {0}", (object)val5));
                    }
                    return result;
                }
            }
            catch (Exception val3)
            {
                Exception val4 = val3;
                Debug.LogError((object)String.Concat("Failed to compute Udon signatures: ", (val4 != null) ? ((Object)val4).ToString() : null));
                throw;
            }
            finally
            {
                EditorPrefs.DeleteKey("currentBuildingAssetBundleCodeSigningKey");
            }
        }
    }
    public class VRCWorldBuilder : Object, ISDKBuilder
    {
        [CompilerGenerated]
        private EventHandler m_OnBuildStarted;
 
        [CompilerGenerated]
        private EventHandler<string> m_OnBuildProgress;
 
        [CompilerGenerated]
        private EventHandler<object> m_OnBuildContentProcessed;
 
        [CompilerGenerated]
        private EventHandler<string> m_OnBuildSuccess;
 
        [CompilerGenerated]
        private EventHandler<ValueTuple<string, string>> m_OnBuildSuccessWithSignature;
 
        [CompilerGenerated]
        private EventHandler<string> m_OnBuildError;
 
        [CompilerGenerated]
        private EventHandler<object> m_OnContentPreUpload;
 
        public string Name => "VRCWorldBuilder";
 
        public event EventHandler OnBuildStarted
        {
            [CompilerGenerated]
            add
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                EventHandler val = this.m_OnBuildStarted;
                EventHandler val2;
                do
                {
                    val2 = val;
                    EventHandler val3 = (EventHandler)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler>(ref this.m_OnBuildStarted, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                //IL_0010: Unknown result type (might be due to invalid IL or missing references)
                //IL_0016: Expected O, but got Unknown
                EventHandler val = this.m_OnBuildStarted;
                EventHandler val2;
                do
                {
                    val2 = val;
                    EventHandler val3 = (EventHandler)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler>(ref this.m_OnBuildStarted, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<string> OnBuildProgress
        {
            [CompilerGenerated]
            add
            {
                EventHandler<string> val = this.m_OnBuildProgress;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildProgress, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<string> val = this.m_OnBuildProgress;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildProgress, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<object> OnBuildContentProcessed
        {
            [CompilerGenerated]
            add
            {
                EventHandler<object> val = this.m_OnBuildContentProcessed;
                EventHandler<object> val2;
                do
                {
                    val2 = val;
                    EventHandler<object> val3 = (EventHandler<object>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<object>>(ref this.m_OnBuildContentProcessed, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<object> val = this.m_OnBuildContentProcessed;
                EventHandler<object> val2;
                do
                {
                    val2 = val;
                    EventHandler<object> val3 = (EventHandler<object>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<object>>(ref this.m_OnBuildContentProcessed, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<string> OnBuildSuccess
        {
            [CompilerGenerated]
            add
            {
                EventHandler<string> val = this.m_OnBuildSuccess;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildSuccess, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<string> val = this.m_OnBuildSuccess;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildSuccess, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<ValueTuple<string, string>> OnBuildSuccessWithSignature
        {
            [CompilerGenerated]
            add
            {
                EventHandler<ValueTuple<string, string>> val = this.m_OnBuildSuccessWithSignature;
                EventHandler<ValueTuple<string, string>> val2;
                do
                {
                    val2 = val;
                    EventHandler<ValueTuple<string, string>> val3 = (EventHandler<ValueTuple<string, string>>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<ValueTuple<string, string>>>(ref this.m_OnBuildSuccessWithSignature, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<ValueTuple<string, string>> val = this.m_OnBuildSuccessWithSignature;
                EventHandler<ValueTuple<string, string>> val2;
                do
                {
                    val2 = val;
                    EventHandler<ValueTuple<string, string>> val3 = (EventHandler<ValueTuple<string, string>>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<ValueTuple<string, string>>>(ref this.m_OnBuildSuccessWithSignature, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<string> OnBuildError
        {
            [CompilerGenerated]
            add
            {
                EventHandler<string> val = this.m_OnBuildError;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildError, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<string> val = this.m_OnBuildError;
                EventHandler<string> val2;
                do
                {
                    val2 = val;
                    EventHandler<string> val3 = (EventHandler<string>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<string>>(ref this.m_OnBuildError, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public event EventHandler<object> OnContentPreUpload
        {
            [CompilerGenerated]
            add
            {
                EventHandler<object> val = this.m_OnContentPreUpload;
                EventHandler<object> val2;
                do
                {
                    val2 = val;
                    EventHandler<object> val3 = (EventHandler<object>)(object)Delegate.Combine((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<object>>(ref this.m_OnContentPreUpload, val3, val2);
                }
                while (val != val2);
            }
            [CompilerGenerated]
            remove
            {
                EventHandler<object> val = this.m_OnContentPreUpload;
                EventHandler<object> val2;
                do
                {
                    val2 = val;
                    EventHandler<object> val3 = (EventHandler<object>)(object)Delegate.Remove((Delegate)(object)val2, (Delegate)(object)value);
                    val = Interlocked.CompareExchange<EventHandler<object>>(ref this.m_OnContentPreUpload, val3, val2);
                }
                while (val != val2);
            }
        }
 
        public void ClearEventHandlers()
        {
            this.OnBuildStarted = null;
            this.OnBuildProgress = null;
            this.OnBuildSuccess = null;
            this.OnBuildSuccessWithSignature = null;
            this.OnBuildError = null;
        }
 
        public void ClearUploadEventHandlers()
        {
            this.OnContentPreUpload = null;
        }
 
        public bool ExportAvatarBlueprint(GameObject externalReference = null)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
 
        public bool ExportAndUploadAvatarBlueprint(GameObject externalReference = null)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
 
        public bool ExportAndTestAvatarBlueprint(GameObject externalReference = null)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
 
        [Obsolete("Use ExportSceneResource followed by VRC.SDKBase.Editor.Api.VRCApi methods instead")]
        public void ExportAndUploadSceneBlueprint()
        {
            Debug.LogError((object)"Uploading via the SDK builder is no longer supported, use ExportSceneResource followed by VRC.SDKBase.Editor.Api.VRCApi methods instead");
        }
 
        [Obsolete("Use ExportSceneResource followed by VRC.SDKBase.Editor.Api.VRCApi methods instead")]
        public void UploadLastExportedSceneBlueprint()
        {
            Debug.LogError((object)"Uploading via the SDK builder is no longer supported, use ExportSceneResource followed by VRC.SDKBase.Editor.Api.VRCApi methods instead");
        }
 
        public void RunLastExportedSceneResource()
        {
            string @string = EditorPrefs.GetString("lastExternalPluginPath");
            string string2 = EditorPrefs.GetString("lastVRCPath");
            if (!String.IsNullOrEmpty(string2) && (String.IsNullOrEmpty(string2) || File.Exists(string2)))
            {
                VRCWorldAssetExporter.RunScene(string2, @string);
            }
            else
            {
                EditorUtility.DisplayDialog("Could not run VRChat scene", "Last built VRChat scene could not be found. Please Test/Compile Full Scene (slow).", "OK");
            }
        }
 
        public void ExportSceneResourceAndRun()
        {
            try
            {
                if (ExportSceneResource())
                {
                    EditorAssemblies.AddOnAssemblyReloadCallback("VRC.SDK3.Editor.AssetExporter", "RunExportedSceneResourceAndCleanupPlugin", true);
                }
                else
                {
                    VRCWorldAssetExporter.RunExportedSceneResourceAndCleanupPlugin();
                }
            }
            catch (Exception)
            {
                AssetExporter.CleanupTmpFiles();
                EditorAssemblies.ClearAssemblyReloadCallbacks();
                throw;
            }
        }
 
        public bool ExportSceneResource()
        {
            return ExportSceneResourceInternal();
        }
 
        private bool ExportSceneResourceInternal(bool buildAssetBundle = true)
        {
            //IL_0115: Expected O, but got Unknown
            //IL_0027: Unknown result type (might be due to invalid IL or missing references)
            //IL_002c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0032: Invalid comparison between Unknown and I4
            //IL_0068: Unknown result type (might be due to invalid IL or missing references)
            //IL_0079: Unknown result type (might be due to invalid IL or missing references)
            //IL_00eb: Unknown result type (might be due to invalid IL or missing references)
            EventHandler onBuildStarted = this.OnBuildStarted;
            if (onBuildStarted != null)
            {
                onBuildStarted.Invoke((object)this, EventArgs.Empty);
            }
            PipelineManager[] array = Object.FindObjectsOfType<PipelineManager>();
            if (array.Length != 0)
            {
                PipelineManager val = array[0];
                val.contentType = (ContentType)1;
                if ((int)VRC_SdkBuilder.ActiveBuildType == 2 && String.IsNullOrEmpty(val.blueprintId))
                {
                    val.AssignId();
                }
                if (buildAssetBundle)
                {
                    EditorPrefs.SetString("lastBuiltAssetBundleBlueprintID", val.blueprintId);
                }
                EditorUtility.SetDirty((Object)(object)array[0]);
                EditorSceneManager.MarkSceneDirty(((Component)val).gameObject.scene);
                EditorSceneManager.SaveScene(((Component)val).gameObject.scene);
            }
            VRCWorldAssetExporter vRCWorldAssetExporter = new VRCWorldAssetExporter();
            try
            {
                vRCWorldAssetExporter.ExportCurrentSceneResource(buildAssetBundle, [CompilerGenerated] (string progress) =>
                {
                    this.OnBuildProgress?.Invoke((object)this, progress);
                }, [CompilerGenerated] (object target) =>
                {
                    this.OnBuildContentProcessed?.Invoke((object)this, target);
                });
                string @string = EditorPrefs.GetString("currentBuildingAssetBundlePath");
                string string2 = EditorPrefs.GetString("currentBuildingAssetBundleWorldSignature");
                if (File.Exists(@string))
                {
                    this.OnBuildSuccess?.Invoke((object)this, @string);
                    this.OnBuildSuccessWithSignature?.Invoke((object)this, new ValueTuple<string, string>(@string, string2));
                    return false;
                }
                this.OnBuildError?.Invoke((object)this, "Failed to build the World. Check the logs for more details");
            }
            catch (Exception val2)
            {
                Exception val3 = val2;
                this.OnBuildError?.Invoke((object)this, val3.Message);
            }
            return false;
        }
 
        public void ExportSceneToV3()
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
 
        public void ExportAvatarToV3(GameObject externalReference = null)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            throw new NotImplementedException();
        }
    }
    public struct AdbResult : ValueType
    {
        public string standardOut;
 
        public string standardError;
 
        public int exitCode;
    }
    public enum DeviceLockState : Enum
    {
        UNKNOWN,
        LOCKED,
        UNLOCKED
    }
    public class ADB : Object
    {
        public static string GetAdbProcessFileName()
        {
            //IL_0005: Unknown result type (might be due to invalid IL or missing references)
            //IL_000f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0019: Unknown result type (might be due to invalid IL or missing references)
            //IL_001f: Invalid comparison between Unknown and I4
            //IL_0030: Unknown result type (might be due to invalid IL or missing references)
            //IL_0036: Unknown result type (might be due to invalid IL or missing references)
            string text = Path.Join(String.op_Implicit(EditorApplication.applicationContentsPath), String.op_Implicit("PlaybackEngines/AndroidPlayer/SDK/platform-tools"));
            string text2 = (((int)Application.platform == 7) ? "adb.exe" : "adb");
            string text3 = Path.Join(String.op_Implicit(text), String.op_Implicit(text2));
            string result = "adb";
            if (File.Exists(text3))
            {
                result = text3;
            }
            return result;
        }
 
        public static ProcessStartInfo GetAdbProcessInfo(Collection<string> arguments, bool redirectStandardOutput = true, bool redirectStandardError = true, bool redirectStandardInput = false)
        {
            //IL_0000: Unknown result type (might be due to invalid IL or missing references)
            //IL_0005: Unknown result type (might be due to invalid IL or missing references)
            //IL_0010: Unknown result type (might be due to invalid IL or missing references)
            //IL_0017: Unknown result type (might be due to invalid IL or missing references)
            //IL_001e: Unknown result type (might be due to invalid IL or missing references)
            //IL_0025: Unknown result type (might be due to invalid IL or missing references)
            //IL_002c: Unknown result type (might be due to invalid IL or missing references)
            //IL_0034: Expected O, but got Unknown
            ProcessStartInfo val = new ProcessStartInfo
            {
                FileName = GetAdbProcessFileName(),
                UseShellExecute = false,
                CreateNoWindow = true,
                RedirectStandardOutput = redirectStandardOutput,
                RedirectStandardError = redirectStandardError,
                RedirectStandardInput = redirectStandardInput
            };
            IEnumerator<string> enumerator = arguments.GetEnumerator();
            try
            {
                while (((IEnumerator)enumerator).MoveNext())
                {
                    string current = enumerator.Current;
                    val.ArgumentList.Add(current);
                }
                return val;
            }
            finally
            {
                if (enumerator != null)
                {
                    ((IDisposable)enumerator).Dispose();
                }
            }
        }
 
        public static AdbResult Command(params string[] arguments)
        {
            Process val = Process.Start(GetAdbProcessInfo(new Collection<string>((IList<string>)(object)arguments)));
            val.WaitForExit();
            string text = ((TextReader)val.StandardOutput).ReadToEnd();
            string text2 = ((TextReader)val.StandardError).ReadToEnd();
            if (val.ExitCode != 0)
            {
                throw new AdbException(val.ExitCode, text, text2);
            }
            AdbResult result = default(AdbResult);
            result.standardOut = text;
            result.standardError = text2;
            result.exitCode = val.ExitCode;
            return result;
        }
 
        public static void Sync()
        {
            Debug.Log((object)String.Concat("ADB sync\n", Command("shell", "sync").standardOut));
        }
 
        public static List<string> GetDevices()
        {
            //IL_0022: Unknown result type (might be due to invalid IL or missing references)
            //IL_0028: Expected O, but got Unknown
            AdbResult adbResult = Command("devices", "-l");
            StringReader val = new StringReader(adbResult.standardOut);
            if (((TextReader)val).ReadLine().Trim() != "List of devices attached")
            {
                throw new AndroidTestBuildException(String.Concat("Command `adb devices` returned unknown result: ", adbResult.standardOut));
            }
            List<string> val2 = new List<string>();
            string text;
            do
            {
                text = ((TextReader)val).ReadLine();
                if (!String.IsNullOrEmpty(text))
                {
                    val2.Add(text);
                }
            }
            while (!String.IsNullOrEmpty(text));
            return val2;
        }
 
        public static void PushFile(string localFilePath, string remoteFilePath)
        {
            Command("push", localFilePath, remoteFilePath);
            Debug.Log((object)String.Concat("Pushed ", localFilePath, " to ", remoteFilePath));
        }
 
        public static void MakeDirectory(string dir)
        {
            Command("shell", "mkdir", "-p", dir);
            Debug.Log((object)String.Concat("Created directory ", dir));
        }
 
        public static void StartVRChat(string remoteBundleFilePath, string appPackageName)
        {
            string text = ((!appPackageName.Contains("quest")) ? String.Concat(appPackageName, "/com.vrchat.app.MainActivity") : String.Concat(appPackageName, "/com.unity3d.player.UnityPlayerActivity"));
            Debug.Log((object)String.Concat((string[])(object)new String[6] { "Starting VRChat into world '", remoteBundleFilePath, "'\\tActivity: ", text, "\n\tlocalWorldPath: ", remoteBundleFilePath }));
            Debug.Log((object)Command("shell", "am", "start", "-n", text, "-a", "android.intent.action.MAIN", "-c", "android.intent.category.LAUNCHER", "-e", "localWorldPath", remoteBundleFilePath, "-e", "watchWorlds", "true").standardOut);
        }
 
        public static bool AdbDirectoryExists(string appPath)
        {
            AdbResult adbResult = Command("shell", "ls", appPath, ">", "/dev/null", "2>&1", "&&", "echo", "\"true\"", "||", "echo", "\"false\"");
            if (adbResult.standardOut.Contains("true"))
            {
                return true;
            }
            if (adbResult.standardOut.Contains("false"))
            {
                return false;
            }
            throw new AndroidTestBuildException(String.Concat("Unknown adb result for directory exists check:\n", adbResult.standardOut, "\nStdErr:", adbResult.standardError));
        }
 
        public static string[] GetPotentialVRChatAppPackages()
        {
            return Command("shell", "ls", "/storage/emulated/0/Android/data/", "|", "grep", "^com.vrchat").standardOut.Trim().Split("\n", (StringSplitOptions)0);
        }
 
        public static bool IsAppOpen(string androidPackageName)
        {
            AdbResult adbResult = default(AdbResult);
            try
            {
                adbResult = Command("shell", "pidof", androidPackageName);
            }
            catch (AdbException ex)
            {
                if (ex.exitCode == 1)
                {
                    return false;
                }
            }
            string text = adbResult.standardOut.Trim();
            if (String.IsNullOrEmpty(text))
            {
                return false;
            }
            string[] array = text.Split(" ", (StringSplitOptions)0);
            if (array.Length < 2)
            {
                return false;
            }
            int num = default(int);
            if (!Int32.TryParse(array[0], ref num))
            {
                return false;
            }
            if (!Int32.TryParse(array[1], ref num))
            {
                return false;
            }
            return true;
        }
 
        public static string GetAndroidAppDataPath()
        {
            string androidPackageName = VRCSettings.AndroidPackageName;
            return String.Concat("/storage/emulated/0/Android/data/", androidPackageName);
        }
 
        public static string GetQuestAppDataPath()
        {
            string questPackageName = VRCSettings.QuestPackageName;
            return String.Concat("/storage/emulated/0/Android/data/", questPackageName);
        }
 
        public static DeviceLockState GetDeviceLockState()
        {
            //IL_0073: Unknown result type (might be due to invalid IL or missing references)
            //IL_0078: Unknown result type (might be due to invalid IL or missing references)
            bool num = Environment.GetEnvironmentVariable("QA_SKIP_WINDOW_LOCK_CHECK", (EnvironmentVariableTarget)1) == "TRUE";
            bool flag = Environment.GetEnvironmentVariable("QA_SKIP_NFC_LOCK_CHECK", (EnvironmentVariableTarget)1) == "TRUE";
            List<Func<DeviceLockState>> val = new List<Func<DeviceLockState>>();
            if (!num)
            {
                val.Add((Func<DeviceLockState>)GetDeviceWindowLockState);
            }
            else
            {
                Debug.LogWarning((object)"QA: Skipping window based lock screen check");
            }
            if (!flag)
            {
                val.Add((Func<DeviceLockState>)GetDeviceNFCLockState);
            }
            else
            {
                Debug.LogWarning((object)"QA: Skipping NFC based lock screen check");
            }
            Enumerator<Func<DeviceLockState>> enumerator = val.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    Func<DeviceLockState> current = enumerator.Current;
                    try
                    {
                        DeviceLockState deviceLockState = current.Invoke();
                        if (deviceLockState != 0)
                        {
                            return deviceLockState;
                        }
                    }
                    catch (AdbException)
                    {
                    }
                }
            }
            finally
            {
                ((IDisposable)enumerator).Dispose();
            }
            return DeviceLockState.UNKNOWN;
            [CompilerGenerated]
            static DeviceLockState GetDeviceNFCLockState()
            {
                IEnumerator<string> enumerator2 = Enumerable.Select<string, string>((IEnumerable<string>)(object)Command("shell", "dumpsys", "nfc", "|", "grep", "-e", "'mScreenState='", "-e", "'Screen State:'").standardOut.Trim().Split("\n", (StringSplitOptions)0), (Func<string, string>)((string x) => x.Trim())).GetEnumerator();
                try
                {
                    while (((IEnumerator)enumerator2).MoveNext())
                    {
                        string current2 = enumerator2.Current;
                        if (current2.EndsWith("UNLOCKED"))
                        {
                            return DeviceLockState.UNLOCKED;
                        }
                        if (current2.EndsWith("LOCKED"))
                        {
                            return DeviceLockState.LOCKED;
                        }
                    }
                }
                finally
                {
                    if (enumerator2 != null)
                    {
                        ((IDisposable)enumerator2).Dispose();
                    }
                }
                return DeviceLockState.UNKNOWN;
            }
            [CompilerGenerated]
            static DeviceLockState GetDeviceWindowLockState()
            {
                AdbResult adbResult = Command("shell", "dumpsys", "window", "|", "grep", "mDreamingLockscreen");
                if (adbResult.standardOut.Trim().EndsWith("mDreamingLockscreen=false"))
                {
                    return DeviceLockState.UNLOCKED;
                }
                if (adbResult.standardOut.Trim().EndsWith("mDreamingLockscreen=true"))
                {
                    return DeviceLockState.LOCKED;
                }
                return DeviceLockState.UNKNOWN;
            }
        }
    }
}