Add VRChat and GitHub packages to Unity project

Assets/VRCSDK/Dependencies/VRChat/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 30c2a98e4c5e4f2428f8abfa92e718e9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/AWS.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 02cde43b860294140a44ee8e3f228987
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/AWS/S3Manager.cs

@@ -0,0 +1,127 @@
+//
+// Copyright 2014-2015 Amazon.com, 
+// Inc. or its affiliates. All Rights Reserved.
+// 
+// Licensed under the AWS Mobile SDK For Unity 
+// Sample Application License Agreement (the "License"). 
+// You may not use this file except in compliance with the 
+// License. A copy of the License is located 
+// in the "license" file accompanying this file. This file is 
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, express or implied. See the License 
+// for the specific language governing permissions and 
+// limitations under the License.
+//
+
+using UnityEngine;
+using System.Collections;
+using UnityEngine.UI;
+using Amazon.S3;
+using Amazon.S3.Model;
+using Amazon.Runtime;
+using System.IO;
+using System;
+using Amazon.S3.Util;
+using System.Collections.Generic;
+using Amazon.CognitoIdentity;
+using Amazon;
+
+public class S3Manager : MonoBehaviour
+{
+	public string IdentityPoolId = "us-east-1:066cd25b-b249-4394-a267-7a49247aa8f9";   // vrchat identity pool id
+	public string CognitoIdentityRegion = RegionEndpoint.USEast1.SystemName;
+	private RegionEndpoint _CognitoIdentityRegion
+	{
+		get { return RegionEndpoint.GetBySystemName(CognitoIdentityRegion); }
+	}
+	public string S3Region = RegionEndpoint.USEast1.SystemName;
+	private RegionEndpoint _S3Region
+	{
+		get { return RegionEndpoint.GetBySystemName(S3Region); }
+	}
+	public string S3BucketName = "vrc-uploads";   // vrchat
+
+
+	private IAmazonS3 _s3Client;
+	private AWSCredentials _credentials;
+
+	private AWSCredentials Credentials
+	{
+		get
+		{
+			if (_credentials == null)
+				_credentials = new CognitoAWSCredentials(IdentityPoolId, _CognitoIdentityRegion);
+			return _credentials;
+		}
+	}
+
+	private IAmazonS3 Client
+	{
+		get
+		{
+			if (_s3Client == null)
+			{
+				_s3Client = new AmazonS3Client(Credentials, _S3Region);
+			}
+			//test comment
+			return _s3Client;
+		}
+	}
+
+	void Start()
+	{
+		UnityInitializer.AttachToGameObject(this.gameObject);
+	}
+
+	/// <summary>
+	/// Post Object to S3 Bucket. 
+	/// </summary>
+	public PostObjectRequest PostObject(string filePath, string s3FolderName, Action<string> onSuccess = null)
+	{
+		string fileName = s3FolderName + "/" + System.IO.Path.GetFileName(filePath);
+		VRC.Core.Logger.Log ("uploading " + fileName, VRC.Core.DebugLevel.All);
+
+        AWSConfigs.LoggingConfig.LogTo = LoggingOptions.None;
+
+        var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+
+		VRC.Core.Logger.Log ("Creating request object", VRC.Core.DebugLevel.All);
+
+        var request = new PostObjectRequest()
+		{
+			Bucket = S3BucketName,
+			Key = fileName,
+			InputStream = stream,
+			CannedACL = S3CannedACL.Private
+		};
+
+		VRC.Core.Logger.Log ("Making HTTP post call", VRC.Core.DebugLevel.All);
+
+		StartCoroutine(PostObjectRoutine(request, onSuccess));
+
+		return request;
+	}
+
+	IEnumerator PostObjectRoutine(PostObjectRequest request, Action<string> onSuccess)
+	{
+		// make sure UnityInitializer call has time to initialize
+		yield return null;
+		yield return null;
+
+		Client.PostObjectAsync(request, (responseObj) =>
+			{
+				if (responseObj.Exception == null)
+				{
+					VRC.Core.Logger.Log("object " + responseObj.Request.Key + " posted to bucket " + responseObj.Request.Bucket, VRC.Core.DebugLevel.All);
+					string s3Url = string.Format("https://s3-us-west-2.amazonaws.com/{0}/{1}", responseObj.Request.Bucket, responseObj.Request.Key);
+					if(onSuccess != null)
+						onSuccess(s3Url);
+				}
+				else
+				{
+					VRC.Core.Logger.Log ("Exception while posting the result object");
+					VRC.Core.Logger.Log("receieved error " + responseObj.Response.HttpStatusCode.ToString());
+				}
+			});
+	}
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/AWS/S3Manager.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3d6a1d7b0624f414ba6fb922687a06da
+timeCreated: 1480975716
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 059f8224659cefb4fa29c1c01d87a653
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline/Samples.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: daf80f83bd8638d4886542fc3230e9f6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline/Samples/VRCSDKBuildRequestedCallbackSample.cs

@@ -0,0 +1,18 @@
+#if VRC_SDK_PIPELINE_SAMPLES
+
+using UnityEditor;
+
+namespace VRC.SDKBase.Editor.BuildPipeline.Samples
+{
+    public class VRCSDKBuildRequestedCallbackSample : IVRCSDKBuildRequestedCallback
+    {
+        public int callbackOrder => 0;
+
+        public bool OnBuildRequested(VRCSDKRequestedBuildType requestedBuildType)
+        {
+            return EditorUtility.DisplayDialog("Build Confirmation", "Are you sure you want to build?", "Yes", "Not Yes");
+        }
+    }
+}
+
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline/Samples/VRCSDKBuildRequestedCallbackSample.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a1d20f4241085e46bdddc71b691465b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline/VRC.SDKBase.Editor.BuildPipeline.asmdef

@@ -0,0 +1,12 @@
+{
+    "name": "VRC.SDKBase.Editor.BuildPipeline",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/BuildPipeline/VRC.SDKBase.Editor.BuildPipeline.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 21332e1f0d937794d916d2402ba1943a
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 095dab1d766b9f74ea16555fc915be80
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/ApiCacheEditor.cs

@@ -0,0 +1,19 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using VRC.Core;
+
+[CustomEditor(typeof(ApiCache))]
+public class ApiCacheEditor : Editor {
+    public override void OnInspectorGUI()
+    {
+        foreach (System.Type type in ApiCache.cache.Keys)
+        {
+            Dictionary<string, ApiCache.CacheEntry> typeCache = ApiCache.cache[type];
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PrefixLabel(type.Name);
+            EditorGUILayout.LabelField(typeCache.Count.ToString());
+            EditorGUILayout.EndHorizontal();
+        }
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/ApiCacheEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 39cdf3092ab81be4b9e623cb5a8819d8
+timeCreated: 1509575680
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/AutoAddSpatialAudioComponents.cs

@@ -0,0 +1,218 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using VRC.SDKBase;
+
+[InitializeOnLoad]
+public class AutoAddSpatialAudioComponents
+{
+
+    public static bool Enabled = true;
+
+    static AutoAddSpatialAudioComponents()
+    {
+        EditorApplication.hierarchyChanged += OnHierarchyWindowChanged;
+		EditorApplication.projectChanged += OnProjectWindowChanged;
+		RegisterCallbacks();
+    }
+
+    static void OnHierarchyWindowChanged()
+    {
+        if (!Enabled)
+        {
+            EditorApplication.hierarchyChanged -= OnHierarchyWindowChanged;
+            return;
+        }
+
+        // check for proper use of VRCSP, and warn
+        //TryToAddSpatializationToAllAudioSources(true, false);
+    }
+
+	static void OnProjectWindowChanged()
+	{
+		RegisterCallbacks();
+	}
+
+	static void RegisterCallbacks()
+	{
+        VRCSdkControlPanel._EnableSpatialization = VRCSDKControlPanel_EnableSpatialization;
+	}
+
+	// callback from VrcSdkControlPanel in dll
+	public static void VRCSDKControlPanel_EnableSpatialization()
+	{
+		Debug.Log("Enabling spatialization on 3D AudioSources...");
+		TryToAddSpatializationToAllAudioSources(false, true);
+	}
+
+    static bool ApplyDefaultSpatializationToAudioSource(AudioSource audioSrc, bool force = false)
+    {
+        if (audioSrc == null)
+            return false;
+
+        var vrcsp = audioSrc.gameObject.GetComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+
+        // don't make changes if we already have a vrcsp and we aren't forcing
+        if (vrcsp != null && !force)
+            return false;
+
+        if (force)
+            audioSrc.spatialBlend = 1;
+
+        bool initValues = force;
+
+        // is audio source set to be 2D?
+        bool is2D = audioSrc.spatialBlend == 0;
+
+        if (vrcsp == null)
+        {
+            // no onsp and no vrcsp, so add
+            vrcsp = audioSrc.gameObject.AddComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+            if (is2D)
+            {
+                // this audio source was marked as 2D, leave the vrcsp disabled
+                vrcsp.EnableSpatialization = false;
+            }
+            initValues = true;
+        }
+
+        audioSrc.spatialize = vrcsp.EnableSpatialization;
+        vrcsp.enabled = true;
+
+        if (initValues)
+        {
+            bool isAvatar = audioSrc.GetComponentInParent<VRC.SDKBase.VRC_AvatarDescriptor>();
+
+            vrcsp.Gain = isAvatar ? VRCSDK2.AudioManagerSettings.AvatarAudioMaxGain : VRCSDK2.AudioManagerSettings.RoomAudioGain;
+            vrcsp.Near = 0;
+            vrcsp.Far = isAvatar ? VRCSDK2.AudioManagerSettings.AvatarAudioMaxRange : VRCSDK2.AudioManagerSettings.RoomAudioMaxRange;
+            vrcsp.UseAudioSourceVolumeCurve = false;
+        }
+
+        return true;
+    }
+
+    public static void TryToAddSpatializationToAllAudioSources(bool newAudioSourcesOnly, bool includeInactive)
+    {
+        AudioSource[] allAudioSources = includeInactive ? Resources.FindObjectsOfTypeAll<AudioSource>() : Object.FindObjectsOfType<AudioSource>();
+        foreach (AudioSource src in allAudioSources)
+        {
+            if (src == null || src.gameObject == null || src.gameObject.scene != UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene())
+            {
+                continue;
+            }
+
+            if (newAudioSourcesOnly)
+            {
+                if (!IsNewAudioSource(src))
+                    continue;
+
+                UnityEngine.Audio.AudioMixerGroup mixer = AssetDatabase.LoadAssetAtPath<UnityEngine.Audio.AudioMixerGroup>("Assets/VRCSDK/Dependencies/OSPNative/scenes/mixers/SpatializerMixer.mixer");
+                if (mixer != null)
+                {
+                    src.outputAudioMixerGroup = mixer;
+                }
+            }
+
+            if (ApplyDefaultSpatializationToAudioSource(src, false))
+            {
+                Debug.Log("Automatically added VRC_SpatialAudioSource component to " + GetGameObjectPath(src.gameObject) + "!");
+            }
+        }
+    }
+
+    static bool IsNewAudioSource(AudioSource src)
+    {
+        var vrcsp = src.GetComponent<VRC_SpatialAudioSource>();
+        if (vrcsp != null)
+            return false;
+
+        if (src.clip != null)
+            return false;
+        if (src.outputAudioMixerGroup != null)
+            return false;
+
+        if (src.mute || src.bypassEffects || src.bypassReverbZones || !src.playOnAwake || src.loop)
+            return false;
+
+        if (src.priority != 128 ||
+            !Mathf.Approximately(src.volume, 1.0f) ||
+            !Mathf.Approximately(src.pitch, 1.0f) ||
+            !Mathf.Approximately(src.panStereo, 0.0f) ||
+            !Mathf.Approximately(src.spatialBlend, 0.0f) ||
+            !Mathf.Approximately(src.reverbZoneMix, 1.0f))
+        {
+            return false;
+        }
+
+        if (!Mathf.Approximately(src.dopplerLevel, 1.0f) ||
+            !Mathf.Approximately(src.spread, 0.0f) ||
+            src.rolloffMode != AudioRolloffMode.Logarithmic ||
+            !Mathf.Approximately(src.minDistance, 1.0f) ||
+            !Mathf.Approximately(src.maxDistance, 500.0f))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    static string GetGameObjectPath(GameObject obj)
+    {
+        string path = "/" + obj.name;
+        while (obj.transform.parent != null)
+        {
+            obj = obj.transform.parent.gameObject;
+            path = "/" + obj.name + path;
+        }
+        return path;
+    }
+
+    public static void ConvertONSPAudioSource(AudioSource src)
+    {
+        if (src == null) return;
+
+        var onsp = src.GetComponent<ONSPAudioSource>();
+        if (onsp != null)
+        {
+            var vrcsp = src.gameObject.GetComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+            if (vrcsp == null)
+            {
+                // copy the values from deprecated component
+                vrcsp = src.gameObject.AddComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+                vrcsp.Gain = onsp.Gain;
+                vrcsp.Near = onsp.Near;
+                vrcsp.Far = onsp.Far;
+                vrcsp.UseAudioSourceVolumeCurve = !onsp.UseInvSqr;
+                vrcsp.EnableSpatialization = onsp.EnableSpatialization;
+            }
+            // remove deprecated component
+            Component.DestroyImmediate(onsp);
+        }
+    }
+
+    public static void AddVRCSpatialToBareAudioSource(AudioSource src)
+    {
+        if (src == null) return;
+
+        var vrcsp = src.gameObject.GetComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+        if (vrcsp != null) return;
+
+        vrcsp = src.gameObject.AddComponent<VRC.SDKBase.VRC_SpatialAudioSource>();
+
+        // add default values
+        bool isAvatar = src.gameObject.GetComponentInParent<VRC.SDKBase.VRC_AvatarDescriptor>();
+
+        vrcsp.Gain = isAvatar ? VRCSDK2.AudioManagerSettings.AvatarAudioMaxGain : VRCSDK2.AudioManagerSettings.RoomAudioGain;
+        vrcsp.Near = 0;
+        vrcsp.Far = isAvatar ? VRCSDK2.AudioManagerSettings.AvatarAudioMaxRange : VRCSDK2.AudioManagerSettings.RoomAudioMaxRange;
+        vrcsp.UseAudioSourceVolumeCurve = false;
+
+        // enable spatialization if src is not 2D
+        AnimationCurve curve = src.GetCustomCurve(AudioSourceCurveType.SpatialBlend);
+        if (src.spatialBlend == 0 || (curve == null || curve.keys.Length <= 1))
+            vrcsp.EnableSpatialization = false;
+        else
+            vrcsp.EnableSpatialization = true;
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/AutoAddSpatialAudioComponents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a364ece829b6234888c59987a305a00
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EditorCoroutine.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+public class EditorCoroutine
+{
+	public static EditorCoroutine Start( IEnumerator _routine )
+	{
+		EditorCoroutine coroutine = new EditorCoroutine(_routine);
+		coroutine.start();
+		return coroutine;
+	}
+
+
+    public static EditorCoroutine Start(System.Action _action)
+    {
+        EditorCoroutine coroutine = new EditorCoroutine(_action);
+        coroutine.start();
+        return coroutine;
+    }
+
+    readonly IEnumerator routine;
+	EditorCoroutine( IEnumerator _routine )
+	{
+		routine = _routine;
+    }
+
+    readonly System.Action action;
+    EditorCoroutine(System.Action _action)
+    {
+        action = _action;
+    }
+
+    void start()
+	{
+		EditorApplication.update += update;
+	}
+	public void stop()
+	{
+        EditorApplication.update -= update;
+	}
+
+	void update()
+	{
+        if (routine != null)
+        {
+            if (!routine.MoveNext())
+                stop();
+        }
+        else if (action != null)
+        {
+            action();
+            stop();
+        }
+        else
+            stop();
+
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EditorCoroutine.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 89005ebc9543e0a4284893c09ca19b1d
+timeCreated: 1473271738
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EditorHandling.cs

@@ -0,0 +1,17 @@
+using UnityEditor;
+using UnityEngine.SceneManagement;
+
+[InitializeOnLoad]
+public static class EditorHandling
+{
+    static EditorHandling()
+    {
+        UnityEditor.SceneManagement.EditorSceneManager.sceneOpened += SceneOpenedCallback;
+    }
+
+    static void SceneOpenedCallback( Scene scene, UnityEditor.SceneManagement.OpenSceneMode mode)
+    {
+        // refresh window when scene is opened to display content images correctly
+        if (null != VRCSdkControlPanel.window) VRCSdkControlPanel.window.Reset();
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EditorHandling.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3d6c2e367eaa9564ebf6267ec163cfbd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EventHandlerEditor.cs

@@ -0,0 +1,357 @@
+#if UNITY_EDITOR
+
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace VRCSDK2
+{
+#if VRC_SDK_VRCSDK2
+    [CustomEditor(typeof(VRCSDK2.VRC_EventHandler))]
+    public class EventHandlerEditor : Editor
+    {
+        bool showDeferredEvents = false;
+
+        static VRCSDK2.VRC_EventHandler.VrcEventType lastAddedEventType = VRCSDK2.VRC_EventHandler.VrcEventType.SendMessage;
+
+        public override void OnInspectorGUI()
+        {
+            VRCSDK2.VRC_EventHandler myTarget = (VRCSDK2.VRC_EventHandler)target;
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("ID:");
+            EditorGUILayout.EndHorizontal();
+
+            if (myTarget.GetComponent<VRCSDK2.VRC_Trigger>() != null)
+            {
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Add Events via the VRC_Trigger on this object.");
+                EditorGUILayout.EndHorizontal();
+            }
+            else
+            {
+                EditorGUI.BeginChangeCheck();
+
+                RenderOldEditor(myTarget);
+
+                if (EditorGUI.EndChangeCheck())
+                    EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+            }
+
+            if (myTarget.deferredEvents.Count > 0)
+            {
+                showDeferredEvents = EditorGUILayout.Foldout(showDeferredEvents, "Deferred Events");
+                if (showDeferredEvents)
+                    RenderEvents(myTarget.deferredEvents);
+            }
+        }
+
+        int[] sendMessageMethodIndicies;
+        private void RenderOldEditor(VRCSDK2.VRC_EventHandler myTarget)
+        {
+            EditorGUILayout.HelpBox("Please use a VRC_Trigger in the future.", MessageType.Error);
+
+            if (GUILayout.Button("Add Event Handler"))
+                myTarget.Events.Add(new VRCSDK2.VRC_EventHandler.VrcEvent());
+
+            bool first = true;
+            int deleteEventIndex = -1;
+            if (sendMessageMethodIndicies == null || sendMessageMethodIndicies.Length != myTarget.Events.Count)
+                sendMessageMethodIndicies = new int[myTarget.Events.Count + 1];
+
+            for (int i = 0; i < myTarget.Events.Count; ++i)
+            {
+                if (!first)
+                    EditorGUILayout.Separator();
+                first = false;
+
+                EditorGUILayout.LabelField("Event " + (i + 1).ToString());
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Event Name");
+                myTarget.Events[i].Name = EditorGUILayout.TextField(myTarget.Events[i].Name);
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Event Type");
+                myTarget.Events[i].EventType = (VRCSDK2.VRC_EventHandler.VrcEventType)EditorGUILayout.EnumPopup(myTarget.Events[i].EventType);
+                EditorGUILayout.EndHorizontal();
+
+                switch (myTarget.Events[i].EventType)
+                {
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.AnimationBool:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Variable");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Operation");
+                        myTarget.Events[i].ParameterBoolOp = (VRCSDK2.VRC_EventHandler.VrcBooleanOp)EditorGUILayout.EnumPopup(myTarget.Events[i].ParameterBoolOp);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.AnimationFloat:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Variable");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Value");
+                        myTarget.Events[i].ParameterFloat = EditorGUILayout.FloatField(myTarget.Events[i].ParameterFloat);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.AnimationTrigger:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Trigger");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.AudioTrigger:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("AudioSource");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.MeshVisibility:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Mesh");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Operation");
+                        myTarget.Events[i].ParameterBoolOp = (VRCSDK2.VRC_EventHandler.VrcBooleanOp)EditorGUILayout.EnumPopup(myTarget.Events[i].ParameterBoolOp);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.PlayAnimation:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Target");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Animation");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.RunConsoleCommand:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Command");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.SendMessage:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Receiver");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Message");
+
+                        // sorry for this shit show. Below allows us to show a list of public methods, but also allow custom messages
+                        var methods = VRC_EditorTools.GetAccessibleMethodsOnGameObject(myTarget.Events[i].ParameterObject);
+                        List<string> methodList = methods.Values.Aggregate(new List<string>(), (acc, lst) => { acc.AddRange(lst.Select(mi => mi.Name)); return acc; });
+                        methodList.Add("Custom Message");
+
+                        string[] _choices = methodList.ToArray();
+
+                        int currentIndex = methodList.Count - 1;
+
+                        if (methodList.Contains(myTarget.Events[i].ParameterString))
+                            currentIndex = methodList.IndexOf(myTarget.Events[i].ParameterString);
+
+                        sendMessageMethodIndicies[i] = EditorGUILayout.Popup(currentIndex, _choices);
+
+                        if (sendMessageMethodIndicies[i] != methodList.Count - 1)
+                        {
+                            myTarget.Events[i].ParameterString = _choices[sendMessageMethodIndicies[i]];
+                        }
+                        else
+                        {
+                            if (methodList.Contains(myTarget.Events[i].ParameterString))
+                                myTarget.Events[i].ParameterString = "";
+
+                            myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        }
+
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.SetGameObjectActive:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("GameObject");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Operation");
+                        myTarget.Events[i].ParameterBoolOp = (VRCSDK2.VRC_EventHandler.VrcBooleanOp)EditorGUILayout.EnumPopup(myTarget.Events[i].ParameterBoolOp);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.SetParticlePlaying:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Target");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Operation");
+                        myTarget.Events[i].ParameterBoolOp = (VRCSDK2.VRC_EventHandler.VrcBooleanOp)EditorGUILayout.EnumPopup(myTarget.Events[i].ParameterBoolOp);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.TeleportPlayer:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Location");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+						EditorGUILayout.BeginHorizontal();
+						EditorGUILayout.LabelField("Align Room To Destination");
+						myTarget.Events[i].ParameterBoolOp = (VRCSDK2.VRC_EventHandler.VrcBooleanOp)EditorGUILayout.EnumPopup(myTarget.Events[i].ParameterBoolOp);
+						EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.SetWebPanelURI:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("URI");
+                        myTarget.Events[i].ParameterString = EditorGUILayout.TextField(myTarget.Events[i].ParameterString);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Panel");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    case VRCSDK2.VRC_EventHandler.VrcEventType.SetWebPanelVolume:
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Volume");
+                        myTarget.Events[i].ParameterFloat = EditorGUILayout.FloatField(myTarget.Events[i].ParameterFloat);
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Panel");
+                        myTarget.Events[i].ParameterObject = (GameObject)EditorGUILayout.ObjectField(myTarget.Events[i].ParameterObject, typeof(GameObject), true);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                    default:
+                        EditorGUILayout.BeginHorizontal();
+                        GUIStyle redText = new GUIStyle();
+                        redText.normal.textColor = Color.red;
+                        EditorGUILayout.LabelField("Unsupported event type", redText);
+                        EditorGUILayout.EndHorizontal();
+                        break;
+                }
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Delete " + myTarget.Events[i].Name + "?");
+                if (GUILayout.Button("delete"))
+                    deleteEventIndex = i;
+                EditorGUILayout.EndHorizontal();
+
+                if (myTarget.Events[i].ParameterObject == null)
+                    myTarget.Events[i].ParameterObject = myTarget.gameObject;
+            }
+
+
+            if (deleteEventIndex != -1)
+                myTarget.Events.RemoveAt(deleteEventIndex);
+        }
+
+        private void RenderEvents(IEnumerable<VRCSDK2.VRC_EventHandler.EventInfo> entries)
+        {
+            foreach (VRCSDK2.VRC_EventHandler.EventInfo entry in entries)
+            {
+                EditorGUILayout.PrefixLabel("Target");
+                EditorGUILayout.ObjectField(entry.evt.ParameterObject, typeof(GameObject), true);
+
+                EditorGUILayout.LabelField(string.Format("Name: {0}", entry.evt.Name));
+                EditorGUILayout.LabelField(string.Format("Type: {0}", entry.evt.EventType));
+                EditorGUILayout.LabelField(string.Format("Bool: {0}", entry.evt.ParameterBool));
+                EditorGUILayout.LabelField(string.Format("Float: {0}", entry.evt.ParameterFloat));
+                EditorGUILayout.LabelField(string.Format("Int: {0}", entry.evt.ParameterInt));
+                EditorGUILayout.LabelField(string.Format("String: {0}", entry.evt.ParameterString));
+
+                EditorGUILayout.Space();
+            }
+        }
+
+        public static void RenderEditor(VRCSDK2.VRC_EventHandler myTarget)
+        {
+            bool first = true;
+            int deleteEventIndex = -1;
+
+            for (int i = 0; i < myTarget.Events.Count; ++i)
+            {
+                if (!first)
+                    EditorGUILayout.Separator();
+                first = false;
+
+                if (RenderEventHeader(myTarget, myTarget.Events[i]))
+                    deleteEventIndex = i;
+
+                RenderEventHeader(myTarget, myTarget.Events[i]);
+
+                if (myTarget.Events[i].ParameterObject == null)
+                    myTarget.Events[i].ParameterObject = myTarget.gameObject;
+            }
+
+            if (deleteEventIndex != -1)
+                myTarget.Events.RemoveAt(deleteEventIndex);
+        }
+
+        public static VRCSDK2.VRC_EventHandler.VrcEvent RenderAddEvent(VRCSDK2.VRC_EventHandler myTarget)
+        {
+            VRCSDK2.VRC_EventHandler.VrcEvent newEvent = null;
+
+            EditorGUILayout.BeginHorizontal();
+            lastAddedEventType = VRC_EditorTools.FilteredEnumPopup("New Event Type", lastAddedEventType, (v) => v != VRCSDK2.VRC_EventHandler.VrcEventType.SpawnObject && v != VRCSDK2.VRC_EventHandler.VrcEventType.SendMessage);
+            if (GUILayout.Button("Add"))
+            {
+                newEvent = new VRCSDK2.VRC_EventHandler.VrcEvent
+                {
+                    EventType = lastAddedEventType,
+                    ParameterObject = myTarget.gameObject
+                };
+                myTarget.Events.Add(newEvent);
+                EditorUtility.SetDirty(myTarget);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            return newEvent;
+        }
+
+        public static bool RenderEventHeader(VRCSDK2.VRC_EventHandler myTarget, VRCSDK2.VRC_EventHandler.VrcEvent evt)
+        {
+            EditorGUILayout.BeginHorizontal();
+            evt.EventType = VRC_EditorTools.FilteredEnumPopup("New Event Type", evt.EventType, (v) => v != VRCSDK2.VRC_EventHandler.VrcEventType.SpawnObject && v != VRCSDK2.VRC_EventHandler.VrcEventType.SendMessage);
+            bool delete = GUILayout.Button("Remove");
+            EditorGUILayout.EndHorizontal();
+
+            return delete;
+        }
+    }
+
+    [CustomEditor(typeof(VRC.SDKBase.VRC_EventHandler))]
+    public class SDKBaseEventHandlerEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("Event Handlers are not supported in VRCSDK3.");
+            if (GUILayout.Button("replace me with the correct VRC_EventHandler"))
+            {
+                var go = ((VRC.SDKBase.VRC_EventHandler)target).gameObject;
+                DestroyImmediate(target);
+                go.AddComponent<VRCSDK2.VRC_EventHandler>();
+            }
+        }
+    }
+#else
+
+    [CustomEditor(typeof(VRC.SDKBase.VRC_EventHandler))]
+    public class SDKBaseEventHandlerEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("Event Handlers are not supported in VRCSDK3.");
+            if( GUILayout.Button("delete me") )
+                DestroyImmediate(target);
+        }
+    }
+
+#endif
+
+
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/EventHandlerEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4810e652e8242384c834320970702290
+timeCreated: 1454469344
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/OldTriggerEditors.cs

@@ -0,0 +1,50 @@
+#if VRC_SDK_VRCSDK2
+
+#if UNITY_EDITOR
+#pragma warning disable 0618
+
+using UnityEditor;
+using System.Collections;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRCSDK2.VRC_KeyEvents))]
+    public class VRC_KeyEventsEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("Obsolete. Please use a VRC_Trigger instead.", MessageType.Error);
+        }
+    }
+
+    [CustomEditor(typeof(VRCSDK2.VRC_UseEvents))]
+    public class VRC_UseEventsEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("Obsolete. Please use a VRC_Trigger instead.", MessageType.Error);
+        }
+    }
+
+    [CustomEditor(typeof(VRCSDK2.VRC_TriggerColliderEventTrigger))]
+    public class VRC_TriggerColliderEventTriggerEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("Obsolete. Please use a VRC_Trigger instead.", MessageType.Error);
+        }
+    }
+
+    [CustomEditor(typeof(VRCSDK2.VRC_TimedEvents))]
+    public class VRC_TimedEventsEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("Obsolete. Please use a VRC_Trigger instead.", MessageType.Error);
+        }
+    }
+}
+
+#pragma warning restore 0618
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/OldTriggerEditors.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 482185bf29f12074dada194ffef6a682
+timeCreated: 1475877803
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCAvatarDescriptorEditor.cs

@@ -0,0 +1,225 @@
+#if VRC_SDK_VRCSDK2
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+using VRC.SDK3.Editor;
+using VRC.SDKBase.Editor;
+
+[CustomEditor(typeof(VRCSDK2.VRC_AvatarDescriptor))]
+public class AvatarDescriptorEditor : Editor
+{
+    VRCSDK2.VRC_AvatarDescriptor avatarDescriptor;
+    VRC.Core.PipelineManager pipelineManager;
+
+    SkinnedMeshRenderer selectedMesh;
+    List<string> blendShapeNames = null;
+
+    bool shouldRefreshVisemes = false;
+
+    public override void OnInspectorGUI()
+    {
+        if (avatarDescriptor == null)
+            avatarDescriptor = (VRCSDK2.VRC_AvatarDescriptor)target;
+
+        if (pipelineManager == null)
+        {
+            pipelineManager = avatarDescriptor.GetComponent<VRC.Core.PipelineManager>();
+            if (pipelineManager == null)
+                avatarDescriptor.gameObject.AddComponent<VRC.Core.PipelineManager>();
+        }
+
+        // DrawDefaultInspector();
+
+        if(VRCSdkControlPanel.window != null)
+        { 
+            if( GUILayout.Button( "Select this avatar in the SDK control panel" ) )
+                VRCSdkControlPanelAvatarBuilder.SelectAvatar(avatarDescriptor);
+        }
+
+        avatarDescriptor.ViewPosition = EditorGUILayout.Vector3Field("View Position", avatarDescriptor.ViewPosition);
+        //avatarDescriptor.Name = EditorGUILayout.TextField("Avatar Name", avatarDescriptor.Name);
+        avatarDescriptor.Animations = (VRCSDK2.VRC_AvatarDescriptor.AnimationSet)EditorGUILayout.EnumPopup("Default Animation Set", avatarDescriptor.Animations);
+        avatarDescriptor.CustomStandingAnims = (AnimatorOverrideController)EditorGUILayout.ObjectField("Custom Standing Anims", avatarDescriptor.CustomStandingAnims, typeof(AnimatorOverrideController), true, null);
+        avatarDescriptor.CustomSittingAnims = (AnimatorOverrideController)EditorGUILayout.ObjectField("Custom Sitting Anims", avatarDescriptor.CustomSittingAnims, typeof(AnimatorOverrideController), true, null);
+        avatarDescriptor.ScaleIPD = EditorGUILayout.Toggle("Scale IPD", avatarDescriptor.ScaleIPD);
+
+        avatarDescriptor.lipSync = (VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle)EditorGUILayout.EnumPopup("Lip Sync", avatarDescriptor.lipSync);
+        switch (avatarDescriptor.lipSync)
+        {
+            case VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.Default:
+                if (GUILayout.Button("Auto Detect!"))
+                    AutoDetectLipSync();
+                break;
+
+            case VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBlendShape:
+                avatarDescriptor.VisemeSkinnedMesh = (SkinnedMeshRenderer)EditorGUILayout.ObjectField("Face Mesh", avatarDescriptor.VisemeSkinnedMesh, typeof(SkinnedMeshRenderer), true);
+                if (avatarDescriptor.VisemeSkinnedMesh != null)
+                {
+                    DetermineBlendShapeNames();
+
+                    int current = -1;
+                    for (int b = 0; b < blendShapeNames.Count; ++b)
+                        if (avatarDescriptor.MouthOpenBlendShapeName == blendShapeNames[b])
+                            current = b;
+
+                    string title = "Jaw Flap Blend Shape";
+                    int next = EditorGUILayout.Popup(title, current, blendShapeNames.ToArray());
+                    if (next >= 0)
+                        avatarDescriptor.MouthOpenBlendShapeName = blendShapeNames[next];
+                }
+                break;
+
+            case VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBone:
+                avatarDescriptor.lipSyncJawBone = (Transform)EditorGUILayout.ObjectField("Jaw Bone", avatarDescriptor.lipSyncJawBone, typeof(Transform), true);
+                break;
+
+            case VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.VisemeBlendShape:
+                SkinnedMeshRenderer prev = avatarDescriptor.VisemeSkinnedMesh;
+                avatarDescriptor.VisemeSkinnedMesh = (SkinnedMeshRenderer)EditorGUILayout.ObjectField("Face Mesh", avatarDescriptor.VisemeSkinnedMesh, typeof(SkinnedMeshRenderer), true);
+                if (avatarDescriptor.VisemeSkinnedMesh != prev)
+                    shouldRefreshVisemes = true;
+                if (avatarDescriptor.VisemeSkinnedMesh != null)
+                {
+                    DetermineBlendShapeNames();
+
+                    if (avatarDescriptor.VisemeBlendShapes == null || avatarDescriptor.VisemeBlendShapes.Length != (int)VRCSDK2.VRC_AvatarDescriptor.Viseme.Count)
+                        avatarDescriptor.VisemeBlendShapes = new string[(int)VRCSDK2.VRC_AvatarDescriptor.Viseme.Count];
+                    for (int i = 0; i < (int)VRCSDK2.VRC_AvatarDescriptor.Viseme.Count; ++i)
+                    {
+                        int current = -1;
+                        for (int b = 0; b < blendShapeNames.Count; ++b)
+                            if (avatarDescriptor.VisemeBlendShapes[i] == blendShapeNames[b])
+                                current = b;
+
+                        string title = "Viseme: " + ((VRCSDK2.VRC_AvatarDescriptor.Viseme)i).ToString();
+                        int next = EditorGUILayout.Popup(title, current, blendShapeNames.ToArray());
+                        if (next >= 0)
+                            avatarDescriptor.VisemeBlendShapes[i] = blendShapeNames[next];
+                    }
+
+                    if (shouldRefreshVisemes)
+                        AutoDetectVisemes();
+                }
+                break;
+        }
+        EditorGUILayout.LabelField("Unity Version", avatarDescriptor.unityVersion);
+    }
+
+    void DetermineBlendShapeNames()
+    {
+        if (avatarDescriptor.VisemeSkinnedMesh != null &&
+            avatarDescriptor.VisemeSkinnedMesh != selectedMesh)
+        {
+            blendShapeNames = new List<string>();
+            blendShapeNames.Add("-none-");
+            selectedMesh = avatarDescriptor.VisemeSkinnedMesh;
+            if ((selectedMesh != null) && (selectedMesh.sharedMesh != null))
+            {
+                for (int i = 0; i < selectedMesh.sharedMesh.blendShapeCount; ++i)
+                    blendShapeNames.Add(selectedMesh.sharedMesh.GetBlendShapeName(i));
+            }
+        }
+    }
+
+    void AutoDetectVisemes()
+    {
+
+        // prioritize strict - but fallback to looser - naming and don't touch user-overrides
+
+        List<string> blendShapes = new List<string>(blendShapeNames);
+        blendShapes.Remove("-none-");
+
+        for (int v = 0; v < avatarDescriptor.VisemeBlendShapes.Length; v++)
+        {
+            if (string.IsNullOrEmpty(avatarDescriptor.VisemeBlendShapes[v]))
+            {
+                string viseme = ((VRCSDK2.VRC_AvatarDescriptor.Viseme)v).ToString().ToLowerInvariant();
+
+                foreach (string s in blendShapes)
+                {
+                    if (s.ToLowerInvariant() == "vrc.v_" + viseme)
+                    {
+                        avatarDescriptor.VisemeBlendShapes[v] = s;
+                        goto next;
+                    }
+                }
+                foreach (string s in blendShapes)
+                {
+                    if (s.ToLowerInvariant() == "v_" + viseme)
+                    {
+                        avatarDescriptor.VisemeBlendShapes[v] = s;
+                        goto next;
+                    }
+                }
+                foreach (string s in blendShapes)
+                {
+                    if (s.ToLowerInvariant().EndsWith(viseme))
+                    {
+                        avatarDescriptor.VisemeBlendShapes[v] = s;
+                        goto next;
+                    }
+                }
+                foreach (string s in blendShapes)
+                {
+                    if (s.ToLowerInvariant() == viseme)
+                    {
+                        avatarDescriptor.VisemeBlendShapes[v] = s;
+                        goto next;
+                    }
+                }
+                foreach (string s in blendShapes)
+                {
+                    if (s.ToLowerInvariant().Contains(viseme))
+                    {
+                        avatarDescriptor.VisemeBlendShapes[v] = s;
+                        goto next;
+                    }
+                }
+                next: { }
+            }
+        }
+
+        shouldRefreshVisemes = false;
+
+    }
+
+    void AutoDetectLipSync()
+    {
+        var smrs = avatarDescriptor.GetComponentsInChildren<SkinnedMeshRenderer>();
+        foreach (var smr in smrs)
+        {
+            if (smr.sharedMesh.blendShapeCount > 0)
+            {
+                avatarDescriptor.lipSyncJawBone = null;
+
+                if (smr.sharedMesh.blendShapeCount > 1)
+                {
+                    avatarDescriptor.lipSync = VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.VisemeBlendShape;
+                    avatarDescriptor.VisemeSkinnedMesh = smr;
+                    shouldRefreshVisemes = true;
+                }
+                else
+                {
+                    avatarDescriptor.lipSync = VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBlendShape;
+                    avatarDescriptor.VisemeSkinnedMesh = null;
+                }
+
+                return;
+            }
+        }
+
+        Animator a = avatarDescriptor.GetComponent<Animator>();
+        if (!a)
+            EditorUtility.DisplayDialog("Ooops", "This avatar has no Animator and can have no lipsync.", "OK");
+        else if (a.GetBoneTransform(HumanBodyBones.Jaw) != null)
+        {
+            avatarDescriptor.lipSync = VRCSDK2.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBone;
+            avatarDescriptor.lipSyncJawBone = avatarDescriptor.GetComponent<Animator>().GetBoneTransform(HumanBodyBones.Jaw);
+            avatarDescriptor.VisemeSkinnedMesh = null;
+            return;
+        }
+
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCAvatarDescriptorEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5e83254bb97e84795ac882692ae124ba
+timeCreated: 1450462624
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCObjectSpawnEditor.cs

@@ -0,0 +1,23 @@
+#if VRC_SDK_VRCSDK2
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using System;
+
+[CustomEditor(typeof(VRCSDK2.VRC_ObjectSpawn))]
+public class VRCObjectSpawnEditor : Editor
+{
+    VRCSDK2.VRC_ObjectSpawn spawn;
+
+    void OnEnable()
+    {
+        if (spawn == null)
+            spawn = (VRCSDK2.VRC_ObjectSpawn)target;
+    }
+
+    public override void OnInspectorGUI()
+    {
+        DrawDefaultInspector();
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCObjectSpawnEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 26a75599848adb449b7aceed5090e35c
+timeCreated: 1463516633
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCObjectSyncEditor.cs

@@ -0,0 +1,25 @@
+#if VRC_SDK_VRCSDK2
+
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using System;
+
+[CustomEditor(typeof(VRCSDK2.VRC_ObjectSync))]
+public class VRCObjectSyncEditor : Editor
+{
+    VRCSDK2.VRC_ObjectSync sync;
+
+    void OnEnable()
+    {
+        if (sync == null)
+            sync = (VRCSDK2.VRC_ObjectSync)target;
+    }
+
+    public override void OnInspectorGUI()
+    {
+        sync.SynchronizePhysics = EditorGUILayout.Toggle("Synchronize Physics",sync.SynchronizePhysics);
+        sync.AllowCollisionTransfer = EditorGUILayout.Toggle("Allow Collision Transfer", sync.AllowCollisionTransfer);
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCObjectSyncEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ed4aad2698d3b62408e69b57c7748791
+timeCreated: 1463516212
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerModEditorWindow.cs

@@ -0,0 +1,37 @@
+#if VRC_SDK_VRCSDK2
+
+using UnityEngine;
+using UnityEditor;
+
+public class VRCPlayerModEditorWindow : EditorWindow {
+
+	public delegate void AddModCallback();
+	public static AddModCallback addModCallback;
+
+	private static VRCSDK2.VRC_PlayerMods myTarget;
+
+	private static VRCSDK2.VRCPlayerModFactory.PlayerModType type;
+
+	public static void Init (VRCSDK2.VRC_PlayerMods target, AddModCallback callback) 
+	{
+		// Get existing open window or if none, make a new one:
+		EditorWindow.GetWindow (typeof (VRCPlayerModEditorWindow));
+		addModCallback = callback;
+		myTarget = target;
+
+		type = VRCSDK2.VRCPlayerModFactory.PlayerModType.Jump;
+	}
+	
+	void OnGUI ()
+	{
+		type = (VRCSDK2.VRCPlayerModFactory.PlayerModType)EditorGUILayout.EnumPopup("Mods", type);
+		if(GUILayout.Button("Add Mod"))
+		{
+			VRCSDK2.VRCPlayerMod mod = VRCSDK2.VRCPlayerModFactory.Create(type);
+			myTarget.AddMod(mod);
+			addModCallback();
+		}
+	}
+}
+
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerModEditorWindow.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8986a640e24a0754ea0aded12234b808
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerModsEditor.cs

@@ -0,0 +1,109 @@
+#if VRC_SDK_VRCSDK2
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using System;
+
+namespace VRCSDK2
+{
+	[CustomEditor(typeof(VRCSDK2.VRC_PlayerMods))]
+	public class VRCPlayerModsEditor : Editor 
+	{
+        VRCSDK2.VRC_PlayerMods myTarget;
+
+		void OnEnable()
+		{
+			if(myTarget == null)
+				myTarget = (VRCSDK2.VRC_PlayerMods)target;
+		}
+
+		public override void OnInspectorGUI()
+		{
+			myTarget.isRoomPlayerMods = EditorGUILayout.Toggle("isRoomPlayerMods", myTarget.isRoomPlayerMods);
+			
+			List<VRCSDK2.VRCPlayerMod> playerMods = myTarget.playerMods;
+			for(int i=0; i<playerMods.Count; ++i)
+			{
+				VRCSDK2.VRCPlayerMod mod = playerMods[i];
+				EditorGUILayout.BeginVertical("box");
+				EditorGUILayout.LabelField(mod.name, EditorStyles.boldLabel);
+				if( mod.allowNameEdit )
+					mod.name = EditorGUILayout.TextField( "Mod Name: ", mod.name );
+				for(int j=0; j<mod.properties.Count; ++j)
+				{
+					VRCSDK2.VRCPlayerModProperty prop = mod.properties[j];
+					myTarget.playerMods[i].properties[j] = DrawFieldForProp(prop);
+				}
+				if(GUILayout.Button ("Remove Mod"))
+				{
+					myTarget.RemoveMod(mod);
+					break;
+				}
+				EditorGUILayout.EndVertical();
+			}
+			if(GUILayout.Button("Add Mods"))
+			{
+				VRCPlayerModEditorWindow.AddModCallback adcb = OnInspectorGUI;
+				VRCPlayerModEditorWindow.Init(myTarget, adcb);
+			}
+		}
+
+		VRCSDK2.VRCPlayerModProperty DrawFieldForProp(VRCSDK2.VRCPlayerModProperty property)
+		{
+			if(property.type.SystemType == typeof(int))
+			{
+				property.intValue = EditorGUILayout.IntField(property.name, property.intValue);
+			}
+			else if(property.type.SystemType == typeof(float))
+			{
+				property.floatValue = EditorGUILayout.FloatField(property.name, property.floatValue);
+			}
+			else if(property.type.SystemType == typeof(string))
+			{
+				property.stringValue = EditorGUILayout.TextField(property.name, property.stringValue);
+			}
+			else if(property.type.SystemType == typeof(bool))
+			{
+				property.boolValue = EditorGUILayout.Toggle(property.name, property.boolValue);
+			}
+			else if(property.type.SystemType == typeof(GameObject))
+			{
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.LabelField( property.name );
+				property.gameObjectValue = (GameObject) EditorGUILayout.ObjectField( property.gameObjectValue, typeof( GameObject ), true );
+				EditorGUILayout.EndHorizontal();
+			}
+			else if(property.type.SystemType == typeof(KeyCode))
+			{
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.LabelField( property.name );
+				property.keyCodeValue = (KeyCode) EditorGUILayout.EnumPopup( property.keyCodeValue );
+				EditorGUILayout.EndHorizontal();
+			}
+			else if(property.type.SystemType == typeof(VRCSDK2.VRC_EventHandler.VrcBroadcastType))
+			{
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.LabelField( property.name );
+				property.broadcastValue = (VRCSDK2.VRC_EventHandler.VrcBroadcastType) EditorGUILayout.EnumPopup( property.broadcastValue );
+				EditorGUILayout.EndHorizontal();
+			}
+			else if(property.type.SystemType == typeof(VRCSDK2.VRCPlayerModFactory.HealthOnDeathAction))
+			{
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.LabelField( property.name );
+				property.onDeathActionValue = (VRCSDK2.VRCPlayerModFactory.HealthOnDeathAction) EditorGUILayout.EnumPopup( property.onDeathActionValue);
+				EditorGUILayout.EndHorizontal();
+			}
+			else if(property.type.SystemType == typeof(RuntimeAnimatorController))
+			{
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.LabelField( property.name );
+				property.animationController = (RuntimeAnimatorController) EditorGUILayout.ObjectField( property.animationController, typeof( RuntimeAnimatorController ), false );
+				EditorGUILayout.EndHorizontal();
+			}
+			return property;
+		}
+	}
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerModsEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 792e7964a56e51f4188e1221751642e9
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerStationEditor.cs

@@ -0,0 +1,46 @@
+#if VRC_SDK_VRCSDK2
+
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using System;
+
+[CustomEditor(typeof(VRCSDK2.VRC_Station))]
+public class VRCPlayerStationEditor : Editor 
+{
+    VRCSDK2.VRC_Station myTarget;
+
+	SerializedProperty onRemoteEnter;
+	SerializedProperty onRemoteExit;
+	SerializedProperty onLocalEnter;
+	SerializedProperty onLocalExit;
+
+	void OnEnable()
+	{
+		if(myTarget == null)
+			myTarget = (VRCSDK2.VRC_Station)target;
+		onRemoteEnter = serializedObject.FindProperty("OnRemotePlayerEnterStation");
+		onRemoteExit = serializedObject.FindProperty("OnRemotePlayerExitStation");
+		onLocalEnter = serializedObject.FindProperty("OnLocalPlayerEnterStation");
+		onLocalExit = serializedObject.FindProperty("OnLocalPlayerExitStation");
+	}
+
+	public override void OnInspectorGUI()
+	{
+		myTarget.PlayerMobility = (VRC.SDKBase.VRCStation.Mobility)EditorGUILayout.EnumPopup("Player Mobility", myTarget.PlayerMobility);
+		myTarget.canUseStationFromStation = EditorGUILayout.Toggle("Can Use Station From Station", myTarget.canUseStationFromStation);
+		myTarget.animatorController = (RuntimeAnimatorController)EditorGUILayout.ObjectField("Animator Controller", myTarget.animatorController, typeof(RuntimeAnimatorController), false);
+		myTarget.disableStationExit = EditorGUILayout.Toggle("Disable Station Exit", myTarget.disableStationExit);
+		myTarget.seated = EditorGUILayout.Toggle("Seated", myTarget.seated);
+		myTarget.stationEnterPlayerLocation = (Transform)EditorGUILayout.ObjectField("Player Enter Location", myTarget.stationEnterPlayerLocation, typeof(Transform), true);
+		myTarget.stationExitPlayerLocation = (Transform)EditorGUILayout.ObjectField("Player Exit Location", myTarget.stationExitPlayerLocation, typeof(Transform), true);
+		myTarget.controlsObject = (VRC.SDKBase.VRC_ObjectApi)EditorGUILayout.ObjectField("API Object", myTarget.controlsObject, typeof(VRC.SDKBase.VRC_ObjectApi), false);
+
+		EditorGUILayout.PropertyField(onRemoteEnter, new GUIContent("On Remote Player Enter"));
+		EditorGUILayout.PropertyField(onRemoteExit, new GUIContent("On Remote Player Exit"));
+		EditorGUILayout.PropertyField(onLocalEnter, new GUIContent("On Local Player Enter"));
+		EditorGUILayout.PropertyField(onLocalExit, new GUIContent("On Local Player Exit"));
+	}
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCPlayerStationEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 5262a02c32e41e047bdfdfc3b63db8ff
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCSceneDescriptorEditor.cs

@@ -0,0 +1,29 @@
+#if VRC_SDK_VRCSDK2
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+[CustomEditor (typeof(VRCSDK2.VRC_SceneDescriptor))]
+public class VRCSceneDescriptorEditor : Editor
+{
+    VRCSDK2.VRC_SceneDescriptor sceneDescriptor;
+    VRC.Core.PipelineManager pipelineManager;
+
+    public override void OnInspectorGUI()
+    {
+        if(sceneDescriptor == null)
+            sceneDescriptor = (VRCSDK2.VRC_SceneDescriptor)target;
+
+        if(pipelineManager == null)
+        {
+            pipelineManager = sceneDescriptor.GetComponent<VRC.Core.PipelineManager>();
+            if(pipelineManager == null)
+                sceneDescriptor.gameObject.AddComponent<VRC.Core.PipelineManager>();
+        }
+
+        DrawDefaultInspector();
+
+
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRCSceneDescriptorEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e9cbc493bbbc443fb92898aa84d221ec
+timeCreated: 1450463561
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_AvatarVariationsEditor.cs

@@ -0,0 +1,130 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace VRCSDK2
+{
+    //[CustomPropertyDrawer(typeof(VRC_AvatarVariations.VariationCategory))]
+    //public class PropertyDrawer_AvatarVariation_VariationCategory : PropertyDrawer
+    //{
+    //    public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+    //    {
+    //        //EditorGUILayout.Label("blah");
+
+    //        if (property == null)
+    //            return;
+
+    //        SerializedProperty nameProperty = property.FindPropertyRelative("name");
+    //        //SerializedProperty mirrorProperty = property.FindPropertyRelative("mirror");
+    //        //SerializedProperty typeProperty = property.FindPropertyRelative("type");
+    //        //SerializedProperty valueProperty = null;
+    //        //switch (typeProperty.enumValueIndex)
+    //        //{
+    //        //    case (int)VRC_DataStorage.VrcDataType.Bool:
+    //        //        valueProperty = property.FindPropertyRelative("valueBool");
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataType.Float:
+    //        //        valueProperty = property.FindPropertyRelative("valueFloat");
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataType.Int:
+    //        //        valueProperty = property.FindPropertyRelative("valueInt");
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataType.String:
+    //        //        valueProperty = property.FindPropertyRelative("valueString");
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataType.SerializeObject:
+    //        //        valueProperty = property.FindPropertyRelative("serializeComponent");
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataType.None:
+    //        //    case (int)VRC_DataStorage.VrcDataType.SerializeBytes:
+    //        //        break;
+    //        //}
+
+    //        EditorGUI.BeginProperty(rect, label, property);
+
+    //        int baseWidth = (int)(rect.width / 4);
+    //        Rect nameRect = new Rect(rect.x, rect.y, baseWidth, rect.height);
+    //        //Rect mirrorRect = new Rect(rect.x + baseWidth, rect.y, baseWidth, rect.height);
+    //        //Rect typeRect = new Rect(rect.x + baseWidth * 2, rect.y, baseWidth, rect.height);
+    //        //Rect valueRect = new Rect(rect.x + baseWidth * 3, rect.y, baseWidth, rect.height);
+    //        //Rect typeValueRect = new Rect(rect.x + baseWidth * 2, rect.y, baseWidth * 2, rect.height);
+
+    //        EditorGUI.PropertyField(nameRect, nameProperty, GUIContent.none);
+    //        //EditorGUI.PropertyField(mirrorRect, mirrorProperty, GUIContent.none);
+
+    //        //switch (mirrorProperty.enumValueIndex)
+    //        //{
+    //        //    case (int)VRC_DataStorage.VrcDataMirror.None:
+    //        //        if (valueProperty == null)
+    //        //            VRC_EditorTools.FilteredEnumPopup<VRC_DataStorage.VrcDataType>(typeValueRect, typeProperty, t => true);
+    //        //        else
+    //        //        {
+    //        //            VRC_EditorTools.FilteredEnumPopup<VRC_DataStorage.VrcDataType>(typeRect, typeProperty, t => true);
+    //        //            EditorGUI.PropertyField(valueRect, valueProperty, GUIContent.none);
+    //        //        }
+    //        //        break;
+    //        //    case (int)VRC_DataStorage.VrcDataMirror.SerializeComponent:
+    //        //        typeProperty.enumValueIndex = (int)VRC_DataStorage.VrcDataType.SerializeObject;
+    //        //        EditorGUI.PropertyField(typeValueRect, valueProperty, GUIContent.none);
+    //        //        break;
+    //        //    default:
+    //        //        VRC_EditorTools.FilteredEnumPopup<VRC_DataStorage.VrcDataType>(typeValueRect, typeProperty, t => true);
+    //        //        break;
+    //        //}
+
+    //        EditorGUI.EndProperty();
+    //    }
+    //}
+
+    //[CustomEditor(typeof(VRC_AvatarVariations))]
+    //public class VRC_AvatarVariationsEditor : Editor
+    //{
+    //    SerializedProperty categories;
+
+    //    void OnEnable()
+    //    {
+    //        categories = serializedObject.FindProperty("categories");
+    //    }
+
+    //    public override void OnInspectorGUI()
+    //    {
+    //        //serializedObject.Update();
+    //        // EditorGUILayout.PropertyField(categories);
+    //        //serializedObject.ApplyModifiedProperties();
+
+
+
+    //        //if (target == null)
+    //        //    return;
+
+    //        ////var prop = serializedObject.FindProperty("root");
+    //        ////EditorGUILayout.PropertyField(prop, new GUIContent("Show Help"));
+    //        //VRCSDK2.VRC_AvatarVariations variations = target as VRCSDK2.VRC_AvatarVariations;
+    //        //if (variations.categories == null)
+    //        //    variations.categories = new VRC_AvatarVariations.VariationCategory[0];
+
+    //        //foreach ( var vc in variations.categories )
+    //        //{
+    //        //    vc.name = EditorGUILayout.TextField("Variation Name", vc.name);
+    //        ////    SerializedProperty triggers = triggersProperty.Copy();
+    //        ////    int triggersLength = triggers.arraySize;
+
+    //        ////    List<int> to_remove = new List<int>();
+    //        ////    for (int idx = 0; idx < triggersLength; ++idx)
+    //        ////    {
+    //        ////        SerializedProperty triggerProperty = triggers.GetArrayElementAtIndex(idx);
+    //        ////    }
+
+    //        ////        EditorGUILayout.LabelField("");
+    //        //////    helpProperty = serializedObject.FindProperty("ShowHelp");
+    //        //////    EditorGUILayout.PropertyField(helpProperty, new GUIContent("Show Help"));
+    //        //}
+
+    //        ////EditorGUILayout.
+
+    //        DrawDefaultInspector();
+    //    }
+    //}
+    
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_AvatarVariationsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: eeda995d0ceac6443a54716996eab52e
+timeCreated: 1511373338
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_DataStorageEditor.cs

@@ -0,0 +1,93 @@
+#if VRC_SDK_VRCSDK2
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+using System.Linq;
+
+namespace VRCSDK2
+{
+    [CustomPropertyDrawer(typeof(VRCSDK2.VRC_DataStorage.VrcDataElement))]
+    public class CustomDataElementDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+        {
+            if (property == null)
+                return;
+
+            SerializedProperty nameProperty = property.FindPropertyRelative("name");
+            SerializedProperty mirrorProperty = property.FindPropertyRelative("mirror");
+            SerializedProperty typeProperty = property.FindPropertyRelative("type");
+            SerializedProperty valueProperty = null;
+            switch (typeProperty.enumValueIndex)
+            {
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.Bool:
+                    valueProperty = property.FindPropertyRelative("valueBool");
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.Float:
+                    valueProperty = property.FindPropertyRelative("valueFloat");
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.Int:
+                    valueProperty = property.FindPropertyRelative("valueInt");
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.String:
+                    valueProperty = property.FindPropertyRelative("valueString");
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.SerializeObject:
+                    valueProperty = property.FindPropertyRelative("serializeComponent");
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.None:
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataType.SerializeBytes:
+                    break;
+            }
+
+            EditorGUI.BeginProperty(rect, label, property);
+
+            int baseWidth = (int)(rect.width / 4);
+            Rect nameRect = new Rect(rect.x, rect.y, baseWidth, rect.height);
+            Rect mirrorRect = new Rect(rect.x + baseWidth, rect.y, baseWidth, rect.height);
+            Rect typeRect = new Rect(rect.x + baseWidth * 2, rect.y, baseWidth, rect.height);
+            Rect valueRect = new Rect(rect.x + baseWidth * 3, rect.y, baseWidth, rect.height);
+            Rect typeValueRect = new Rect(rect.x + baseWidth * 2, rect.y, baseWidth * 2, rect.height);
+
+            EditorGUI.PropertyField(nameRect, nameProperty, GUIContent.none);
+            EditorGUI.PropertyField(mirrorRect, mirrorProperty, GUIContent.none);
+
+            switch (mirrorProperty.enumValueIndex)
+            {
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataMirror.None:
+                    if (valueProperty == null)
+                        VRC_EditorTools.FilteredEnumPopup<VRCSDK2.VRC_DataStorage.VrcDataType>(typeValueRect, typeProperty, t => true);
+                    else
+                    {
+                        VRC_EditorTools.FilteredEnumPopup<VRCSDK2.VRC_DataStorage.VrcDataType>(typeRect, typeProperty, t => true);
+                        EditorGUI.PropertyField(valueRect, valueProperty, GUIContent.none);
+                    }
+                    break;
+                case (int)VRCSDK2.VRC_DataStorage.VrcDataMirror.SerializeComponent:
+                    typeProperty.enumValueIndex = (int)VRCSDK2.VRC_DataStorage.VrcDataType.SerializeObject;
+                    EditorGUI.PropertyField(typeValueRect, valueProperty, GUIContent.none);
+                    break;
+                default:
+                    VRC_EditorTools.FilteredEnumPopup<VRCSDK2.VRC_DataStorage.VrcDataType>(typeValueRect, typeProperty, t => true);
+                    break;
+            }
+
+            EditorGUI.EndProperty();
+        }
+    }
+
+    [CustomEditor(typeof(VRCSDK2.VRC_DataStorage)), CanEditMultipleObjects]
+    public class VRC_DataStorageEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            VRCSDK2.VRC_ObjectSync os = ((VRCSDK2.VRC_DataStorage)target).GetComponent<VRCSDK2.VRC_ObjectSync>();
+            if (os != null && os.SynchronizePhysics)
+                EditorGUILayout.HelpBox("Consider either removing the VRC_ObjectSync or disabling SynchronizePhysics.", MessageType.Warning);
+
+            DrawDefaultInspector();
+        }
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_DataStorageEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0ac7998a36f085844847acbc046d4e27
+timeCreated: 1478191469
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_DestructibleStandardEditor.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using VRC.SDKBase;
+
+[CustomEditor(typeof(VRC_DestructibleStandard))]
+[CanEditMultipleObjects]
+public class VRC_DestructibleStandardEditor : Editor
+{
+	VRC_DestructibleStandard ds;
+
+	SerializedProperty maxHealth;
+	SerializedProperty currentHealth;
+	SerializedProperty healable;
+	SerializedProperty onDamagedTrigger;
+	SerializedProperty onDestroyedTrigger;
+	SerializedProperty onHealedTrigger;
+	SerializedProperty onFullHealedTrigger;
+
+	void OnEnable()
+	{
+		maxHealth = serializedObject.FindProperty("maxHealth");	
+		currentHealth = serializedObject.FindProperty("currentHealth");
+		healable = serializedObject.FindProperty("healable");
+		onDamagedTrigger = serializedObject.FindProperty("onDamagedTrigger");
+		onDestroyedTrigger = serializedObject.FindProperty("onDestructedTrigger");
+		onHealedTrigger = serializedObject.FindProperty("onHealedTrigger");
+		onFullHealedTrigger = serializedObject.FindProperty("onFullHealedTrigger");
+	}
+
+	public override void OnInspectorGUI()
+	{
+		ds = (VRC_DestructibleStandard)target;
+
+		// Update the serializedProperty - always do this in the beginning of OnInspectorGUI.
+		serializedObject.Update ();
+
+		EditorGUILayout.PropertyField(maxHealth, new GUIContent("Max Health"));
+		EditorGUILayout.PropertyField(currentHealth, new GUIContent("Current Health"));
+		EditorGUILayout.PropertyField(healable, new GUIContent("Is Healable"));
+
+		EditorGUILayout.PropertyField(onDamagedTrigger, new GUIContent("On Damaged Trigger"));
+        VRCSDK2.VRC_EditorTools.DrawTriggerActionCallback("On Damaged Action", ds.onDamagedTrigger, ds.onDamagedEvent);
+
+		EditorGUILayout.PropertyField(onDestroyedTrigger, new GUIContent("On Destructed Trigger"));
+		VRCSDK2.VRC_EditorTools.DrawTriggerActionCallback("On Destructed Action", ds.onDestructedTrigger, ds.onDestructedEvent);
+
+		EditorGUILayout.PropertyField(onHealedTrigger, new GUIContent("On Healed Trigger"));
+		VRCSDK2.VRC_EditorTools.DrawTriggerActionCallback("On Healed Action", ds.onHealedTrigger, ds.onHealedEvent);
+
+		EditorGUILayout.PropertyField(onFullHealedTrigger, new GUIContent("On Full Healed Trigger"));
+		VRCSDK2.VRC_EditorTools.DrawTriggerActionCallback("On Full Healed Action", ds.onFullHealedTrigger, ds.onFullHealedEvent);
+
+		// Apply changes to the serializedProperty - always do this in the end of OnInspectorGUI.
+		serializedObject.ApplyModifiedProperties ();
+	}
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_DestructibleStandardEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3b63b118c0591b548ba1797e6be4292e
+timeCreated: 1477161996
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_ObjectSyncEditor.cs

@@ -0,0 +1,19 @@
+#if VRC_SDK_VRCSDK2
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(VRCSDK2.VRC_ObjectSync))]
+public class VRC_ObjectSyncEditor : Editor {
+    public override void OnInspectorGUI()
+    {
+        VRCSDK2.VRC_ObjectSync c = ((VRCSDK2.VRC_ObjectSync)target);
+        if ((c.gameObject.GetComponent<Animator>() != null || c.gameObject.GetComponent<Animation>() != null) && c.SynchronizePhysics)
+            EditorGUILayout.HelpBox("If the Animator or Animation moves the root position of this object then it will conflict with physics synchronization.", MessageType.Warning);
+        if (c.GetComponent<VRCSDK2.VRC_DataStorage>() != null && c.SynchronizePhysics)
+            EditorGUILayout.HelpBox("Consider either removing the VRC_DataStorage or disabling SynchronizePhysics.", MessageType.Warning);
+        DrawDefaultInspector();
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_ObjectSyncEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e19a7147a2386554a8e4d6e414f190a2
+timeCreated: 1504908295
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_PickupEditor.cs

@@ -0,0 +1,76 @@
+#if VRC_SDK_VRCSDK2
+#if UNITY_EDITOR
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Build;
+using System;
+using System.Linq;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRCSDK2.VRC_Pickup))]
+    public class VRC_PickupEditor : Editor
+    {
+        private void InspectorField(string propertyName, string humanName)
+        {
+            SerializedProperty propertyField = serializedObject.FindProperty(propertyName);
+            EditorGUILayout.PropertyField(propertyField, new GUIContent(humanName), true);
+        }
+
+        private SerializedProperty momentumTransferMethodProperty;
+        private SerializedProperty disallowTheftProperty;
+        private SerializedProperty exactGunProperty;
+        private SerializedProperty exactGripProperty;
+        private SerializedProperty allowManipulationWhenEquippedProperty;
+        private SerializedProperty orientationProperty;
+        private SerializedProperty autoHoldProperty;
+        private SerializedProperty interactionTextProperty;
+        private SerializedProperty useTextProperty;
+        private SerializedProperty throwVelocityBoostMinSpeedProperty;
+        private SerializedProperty throwVelocityBoostScaleProperty;
+        private SerializedProperty pickupableProperty;
+        private SerializedProperty proximityProperty;
+
+        public override void OnInspectorGUI()
+        {
+            momentumTransferMethodProperty = serializedObject.FindProperty("MomentumTransferMethod");
+            disallowTheftProperty = serializedObject.FindProperty("DisallowTheft");
+            exactGunProperty = serializedObject.FindProperty("ExactGun");
+            exactGripProperty = serializedObject.FindProperty("ExactGrip");
+            allowManipulationWhenEquippedProperty = serializedObject.FindProperty("allowManipulationWhenEquipped");
+            orientationProperty = serializedObject.FindProperty("orientation");
+            autoHoldProperty = serializedObject.FindProperty("AutoHold");
+            interactionTextProperty = serializedObject.FindProperty("InteractionText");
+            useTextProperty = serializedObject.FindProperty("UseText");
+            throwVelocityBoostMinSpeedProperty = serializedObject.FindProperty("ThrowVelocityBoostMinSpeed");
+            throwVelocityBoostScaleProperty = serializedObject.FindProperty("ThrowVelocityBoostScale");
+            pickupableProperty = serializedObject.FindProperty("pickupable");
+            proximityProperty = serializedObject.FindProperty("proximity");
+
+            EditorGUILayout.BeginVertical(GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 30));
+
+            EditorGUILayout.PropertyField(momentumTransferMethodProperty, new GUIContent("Momentum Transfer Method"));
+            EditorGUILayout.PropertyField(disallowTheftProperty, new GUIContent("Disallow Theft"));
+            EditorGUILayout.PropertyField(exactGunProperty, new GUIContent("Exact Gun"));
+            EditorGUILayout.PropertyField(exactGripProperty, new GUIContent("Exact Grip"));
+            EditorGUILayout.PropertyField(allowManipulationWhenEquippedProperty, new GUIContent("Allow Manipulation When Equipped"));
+            EditorGUILayout.PropertyField(orientationProperty, new GUIContent("Orientation"));
+            EditorGUILayout.PropertyField(autoHoldProperty, new GUIContent("AutoHold", "If the pickup is supposed to be aligned to the hand (i.e. orientation field is set to Gun or Grip), auto-detect means that it will be Equipped(not dropped when they release trigger),  otherwise just hold as a normal pickup."));
+            EditorGUILayout.PropertyField(interactionTextProperty, new GUIContent("Interaction Text","Text displayed when user hovers over the pickup."));
+            if (autoHoldProperty.enumValueIndex != (int)VRCSDK2.VRC_Pickup.AutoHoldMode.No)
+                EditorGUILayout.PropertyField(useTextProperty, new GUIContent("Use Text", "Text to display describing action for clicking button, when this pickup is already being held."));
+            EditorGUILayout.PropertyField(throwVelocityBoostMinSpeedProperty, new GUIContent("Throw Velocity Boost Min Speed"));
+            EditorGUILayout.PropertyField(throwVelocityBoostScaleProperty, new GUIContent("Throw Velocity Boost Scale"));
+            EditorGUILayout.PropertyField(pickupableProperty, new GUIContent("Pickupable"));
+            EditorGUILayout.PropertyField(proximityProperty, new GUIContent("Proximity"));
+
+            EditorGUILayout.EndVertical();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_PickupEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4aff4e5c0d600c845b29d7b8b7965d68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_PlayerAudioOverrideEditor.cs

@@ -0,0 +1,106 @@
+#if VRC_SDK_VRCSDK2
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEditor;
+using System;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRCSDK2.VRC_PlayerAudioOverride))]
+    public class VRC_PlayerAudioOverrideEditor : Editor
+    {
+        private bool voShow = true;
+        private bool voAdv = false;
+        private bool avShow = true;
+        private bool avAdv = false;
+        private SerializedProperty prioProperty;
+        private SerializedProperty globalProperty;
+        private SerializedProperty regionProperty;
+        private SerializedProperty voGainProperty;
+        private SerializedProperty voNearProperty;
+        private SerializedProperty voFarProperty;
+        private SerializedProperty voRadiusProperty;
+        private SerializedProperty voDisableLpProperty;
+        private SerializedProperty avGainProperty;
+        private SerializedProperty avNearProperty;
+        private SerializedProperty avFarProperty;
+        private SerializedProperty avRadiusProperty;
+        private SerializedProperty avForceSpatialProperty;
+        private SerializedProperty avAllowCustomProperty;
+
+        public override void OnInspectorGUI()
+        {
+            globalProperty = serializedObject.FindProperty("global");
+            regionProperty = serializedObject.FindProperty("region");
+            prioProperty = serializedObject.FindProperty("regionPriority");
+
+            voGainProperty = serializedObject.FindProperty("VoiceGain");
+            voNearProperty = serializedObject.FindProperty("VoiceNear");
+            voFarProperty = serializedObject.FindProperty("VoiceFar");
+            voRadiusProperty = serializedObject.FindProperty("VoiceVolumetricRadius");
+            voDisableLpProperty = serializedObject.FindProperty("VoiceDisableLowpass");
+
+            avGainProperty = serializedObject.FindProperty("AvatarGainLimit");
+            avNearProperty = serializedObject.FindProperty("AvatarNearLimit");
+            avFarProperty = serializedObject.FindProperty("AvatarFarLimit");
+            avRadiusProperty = serializedObject.FindProperty("AvatarVolumetricRadiusLimit");
+            avForceSpatialProperty = serializedObject.FindProperty("AvatarForceSpatial");
+            avAllowCustomProperty = serializedObject.FindProperty("AvatarAllowCustomCurve");
+
+            serializedObject.Update();
+
+            EditorGUILayout.BeginVertical();
+
+            var ovr = serializedObject.targetObject as VRCSDK2.VRC_PlayerAudioOverride;
+
+            EditorGUILayout.PropertyField(globalProperty, new GUIContent("Global"));
+            if (!ovr.global)
+            {
+                EditorGUILayout.PropertyField(regionProperty, new GUIContent("Region"));
+                EditorGUILayout.PropertyField(prioProperty, new GUIContent("Priority"));
+            }
+
+            voShow = EditorGUILayout.Foldout(voShow, "Voice Settings");
+
+            if (voShow)
+            {
+                EditorGUILayout.PropertyField(voGainProperty, new GUIContent("Gain"));
+                EditorGUILayout.PropertyField(voFarProperty, new GUIContent("Far"));
+
+                EditorGUI.indentLevel++;
+                voAdv = EditorGUILayout.Foldout(voAdv, "Advanced Options");
+                if (voAdv)
+                {
+                    EditorGUILayout.PropertyField(voNearProperty, new GUIContent("Near"));
+                    EditorGUILayout.PropertyField(voRadiusProperty, new GUIContent("Volumetric Radius"));
+                    EditorGUILayout.PropertyField(voDisableLpProperty, new GUIContent("Disable Lowpass Filter"));
+                }
+                EditorGUI.indentLevel--;
+            }
+
+            avShow = EditorGUILayout.Foldout(avShow, "Avatar Audio Limits");
+
+            if (avShow)
+            {
+                EditorGUILayout.PropertyField(avGainProperty, new GUIContent("Gain Limit"));
+                EditorGUILayout.PropertyField(avFarProperty, new GUIContent("Far Limit"));
+
+                EditorGUI.indentLevel++;
+                avAdv = EditorGUILayout.Foldout(avAdv, "Advanced Options");
+                if (avAdv)
+                {
+                    EditorGUILayout.PropertyField(avNearProperty, new GUIContent("Near Limit"));
+                    EditorGUILayout.PropertyField(avRadiusProperty, new GUIContent("Volumetric Radius Limit"));
+                    EditorGUILayout.PropertyField(avForceSpatialProperty, new GUIContent("Force Spatial"));
+                    EditorGUILayout.PropertyField(avAllowCustomProperty, new GUIContent("Allow Custom Curve"));
+                }
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUILayout.EndVertical();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_PlayerAudioOverrideEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5c545625e0bf93045ac1c5864141c5c1
+timeCreated: 1474315179
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SpatialAudioSourceEditor.cs

@@ -0,0 +1,60 @@
+#if VRC_SDK_VRCSDK2
+#if UNITY_EDITOR
+
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEditor;
+using System;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRCSDK2.VRC_SpatialAudioSource))]
+    public class VRC_SpatialAudioSourceEditor : Editor
+    {
+        private bool showAdvancedOptions = false;
+        private SerializedProperty gainProperty;
+        private SerializedProperty nearProperty;
+        private SerializedProperty farProperty;
+        private SerializedProperty volRadiusProperty;
+        private SerializedProperty enableSpatialProperty;
+        private SerializedProperty useCurveProperty;
+
+        public override void OnInspectorGUI()
+        {
+            gainProperty = serializedObject.FindProperty("Gain");
+            nearProperty = serializedObject.FindProperty("Near");
+            farProperty = serializedObject.FindProperty("Far");
+            volRadiusProperty = serializedObject.FindProperty("VolumetricRadius");
+            enableSpatialProperty = serializedObject.FindProperty("EnableSpatialization");
+            useCurveProperty = serializedObject.FindProperty("UseAudioSourceVolumeCurve");
+
+            serializedObject.Update();
+
+            VRCSDK2.VRC_SpatialAudioSource target = serializedObject.targetObject as VRCSDK2.VRC_SpatialAudioSource;
+            AudioSource source = target.GetComponent<AudioSource>();
+
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(gainProperty, new GUIContent("Gain"));
+            EditorGUILayout.PropertyField(farProperty, new GUIContent("Far"));
+            showAdvancedOptions = EditorGUILayout.Foldout(showAdvancedOptions, "Advanced Options");
+            bool enableSp = enableSpatialProperty.boolValue;
+            if (showAdvancedOptions)
+            {
+                EditorGUILayout.PropertyField(nearProperty, new GUIContent("Near"));
+                EditorGUILayout.PropertyField(volRadiusProperty, new GUIContent("Volumetric Radius"));
+                EditorGUILayout.PropertyField(enableSpatialProperty, new GUIContent("Enable Spatialization"));
+                if (enableSp)
+                    EditorGUILayout.PropertyField(useCurveProperty, new GUIContent("Use AudioSource Volume Curve"));
+            }
+
+            EditorGUILayout.EndVertical();
+
+            if (source != null)
+                source.spatialize = enableSp;
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SpatialAudioSourceEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0d2d4cba733f5eb4ba170368e67710d2
+timeCreated: 1474315179
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SyncVideoPlayerEditor.cs

@@ -0,0 +1,104 @@
+#if VRC_SDK_VRCSDK2
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEditorInternal;
+
+[CustomPropertyDrawer(typeof(VRCSDK2.VRC_SyncVideoPlayer.VideoEntry))]
+public class CustomVideoEntryDrawer : PropertyDrawer
+{    
+    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+    {
+        SerializedProperty source = property.FindPropertyRelative("Source");
+        SerializedProperty ratio = property.FindPropertyRelative("AspectRatio");
+        SerializedProperty speed = property.FindPropertyRelative("PlaybackSpeed");
+        SerializedProperty clip = property.FindPropertyRelative("VideoClip");
+        SerializedProperty url = property.FindPropertyRelative("URL");
+
+        return EditorGUI.GetPropertyHeight(source, new GUIContent("Source"), true) + EditorGUIUtility.standardVerticalSpacing
+            + EditorGUI.GetPropertyHeight(ratio, new GUIContent("Aspect Ratio"), true) + EditorGUIUtility.standardVerticalSpacing
+            + EditorGUI.GetPropertyHeight(speed, new GUIContent("Playback Speed"), true) + EditorGUIUtility.standardVerticalSpacing
+            + Mathf.Max(EditorGUI.GetPropertyHeight(clip, new GUIContent("VideoClip"), true), EditorGUI.GetPropertyHeight(url, new GUIContent("URL"), true)) + EditorGUIUtility.standardVerticalSpacing;
+    }
+
+    public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+    {
+        SerializedProperty source = property.FindPropertyRelative("Source");
+        SerializedProperty ratio = property.FindPropertyRelative("AspectRatio");
+        SerializedProperty speed = property.FindPropertyRelative("PlaybackSpeed");
+        SerializedProperty clip = property.FindPropertyRelative("VideoClip");
+        SerializedProperty url = property.FindPropertyRelative("URL");
+
+        EditorGUI.BeginProperty(rect, label, property);
+        float x = rect.x;
+        float y = rect.y;
+        float w = rect.width;
+        float h = EditorGUI.GetPropertyHeight(source, new GUIContent("Source"), true) + EditorGUIUtility.standardVerticalSpacing;
+        VRCSDK2.VRC_EditorTools.FilteredEnumPopup<UnityEngine.Video.VideoSource>(new Rect(x, y, w, h), source, (e) => e == UnityEngine.Video.VideoSource.Url);
+        y += h;
+
+        if (source.enumValueIndex == (int)UnityEngine.Video.VideoSource.Url)
+        {
+            h = EditorGUI.GetPropertyHeight(url, new GUIContent("URL"), true) + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(new Rect(x, y, w, h), url);
+            y += h;
+        }
+        else
+        {
+            h = EditorGUI.GetPropertyHeight(clip, new GUIContent("VideoClip"), true) + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(new Rect(x, y, w, h), clip);
+            y += h;
+        }
+
+        h = EditorGUI.GetPropertyHeight(ratio, new GUIContent("AspectRatio"), true) + EditorGUIUtility.standardVerticalSpacing;
+        EditorGUI.PropertyField(new Rect(x, y, w, h), ratio);
+        y += h;
+
+        h = EditorGUI.GetPropertyHeight(ratio, new GUIContent("Playback Speed"), true) + EditorGUIUtility.standardVerticalSpacing;
+        EditorGUI.PropertyField(new Rect(x, y, w, h), speed);
+        if (speed.floatValue == 0f)
+            speed.floatValue = 1f;
+        y += h;
+
+        EditorGUI.EndProperty();
+    }
+}
+
+[CustomEditor(typeof(VRCSDK2.VRC_SyncVideoPlayer))]
+public class SyncVideoPlayerEditor : Editor
+{
+    ReorderableList sourceList;
+
+    public override void OnInspectorGUI()
+    {
+        SerializedProperty searchRoot = serializedObject.FindProperty("VideoSearchRoot");
+        EditorGUILayout.PropertyField(searchRoot);
+        SerializedProperty maxQual = serializedObject.FindProperty("MaxStreamQuality");
+        EditorGUILayout.PropertyField(maxQual);
+
+        EditorGUILayout.Space();
+
+        sourceList.DoLayoutList();
+
+        serializedObject.ApplyModifiedProperties();
+    }
+
+    private void OnEnable()
+    {
+        SerializedProperty videos = serializedObject.FindProperty("Videos");
+        sourceList = new ReorderableList(serializedObject, videos);
+        sourceList.drawElementCallback += (Rect rect, int index, bool active, bool focused) =>
+        {
+            EditorGUI.PropertyField(rect, serializedObject.FindProperty("Videos").GetArrayElementAtIndex(index));
+        };
+        sourceList.elementHeightCallback += (int index) =>
+        {
+            SerializedProperty element = serializedObject.FindProperty("Videos").GetArrayElementAtIndex(index);
+            return EditorGUI.GetPropertyHeight(element);
+        };
+        sourceList.drawHeaderCallback = (Rect rect) => EditorGUI.LabelField(rect, "Videos");
+    }
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SyncVideoPlayerEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ae0e74693b7899f47bd98864f94b9311
+timeCreated: 1499468412
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SyncVideoStreamEditor.cs

@@ -0,0 +1,116 @@
+#if VRC_SDK_VRCSDK2
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEditorInternal;
+
+[CustomPropertyDrawer(typeof(VRCSDK2.VRC_SyncVideoStream.VideoEntry))]
+public class CustomVideoStreamEntryDrawer : PropertyDrawer
+{
+    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+    {
+        SerializedProperty source = property.FindPropertyRelative("Source");
+        SerializedProperty speed = property.FindPropertyRelative("PlaybackSpeed");
+        SerializedProperty clip = property.FindPropertyRelative("VideoClip");
+        SerializedProperty url = property.FindPropertyRelative("URL");
+        SerializedProperty live = property.FindPropertyRelative("SyncType");
+        SerializedProperty sync = property.FindPropertyRelative("SyncMinutes");
+
+        return EditorGUI.GetPropertyHeight(source, new GUIContent("Source"), true) + EditorGUIUtility.standardVerticalSpacing
+            + EditorGUI.GetPropertyHeight(speed, new GUIContent("Playback Speed"), true) + EditorGUIUtility.standardVerticalSpacing
+            + Mathf.Max(EditorGUI.GetPropertyHeight(clip, new GUIContent("VideoClip"), true), EditorGUI.GetPropertyHeight(url, new GUIContent("URL"), true)) + EditorGUIUtility.standardVerticalSpacing
+            + EditorGUI.GetPropertyHeight(live, new GUIContent("SyncType"), true) + EditorGUIUtility.standardVerticalSpacing
+            + EditorGUI.GetPropertyHeight(sync, new GUIContent("SyncMinutes"), true) + EditorGUIUtility.standardVerticalSpacing;
+    }
+
+    public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+    {
+        SerializedProperty source = property.FindPropertyRelative("Source");
+        SerializedProperty speed = property.FindPropertyRelative("PlaybackSpeed");
+        SerializedProperty clip = property.FindPropertyRelative("VideoClip");
+        SerializedProperty url = property.FindPropertyRelative("URL");
+        SerializedProperty live = property.FindPropertyRelative("SyncType");
+        SerializedProperty sync = property.FindPropertyRelative("SyncMinutes");
+
+        EditorGUI.BeginProperty(rect, label, property);
+        float x = rect.x;
+        float y = rect.y;
+        float w = rect.width;
+        float h = EditorGUI.GetPropertyHeight(source, new GUIContent("Source"), true) + EditorGUIUtility.standardVerticalSpacing;
+        VRCSDK2.VRC_EditorTools.FilteredEnumPopup<UnityEngine.Video.VideoSource>(new Rect(x, y, w, h), source, (e) => e == UnityEngine.Video.VideoSource.Url);
+        y += h;
+
+        if (source.enumValueIndex == (int)UnityEngine.Video.VideoSource.Url)
+        {
+            h = EditorGUI.GetPropertyHeight(url, new GUIContent("URL"), true) + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(new Rect(x, y, w, h), url);
+            y += h;
+        }
+        else
+        {
+            h = EditorGUI.GetPropertyHeight(clip, new GUIContent("VideoClip"), true) + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(new Rect(x, y, w, h), clip);
+            y += h;
+        }
+
+        h = EditorGUI.GetPropertyHeight(speed, new GUIContent("Playback Speed"), true) + EditorGUIUtility.standardVerticalSpacing;
+        EditorGUI.PropertyField(new Rect(x, y, w, h), speed);
+        if (speed.floatValue == 0f)
+            speed.floatValue = 1f;
+        y += h;
+
+        h = EditorGUI.GetPropertyHeight(live, new GUIContent("SyncType"), true) + EditorGUIUtility.standardVerticalSpacing;
+        EditorGUI.PropertyField(new Rect(x, y, w, h), live);
+        y += h;
+
+        h = EditorGUI.GetPropertyHeight(sync, new GUIContent("SyncMinutes"), true) + EditorGUIUtility.standardVerticalSpacing;
+        EditorGUI.PropertyField(new Rect(x, y, w, h), sync);
+        if (sync.floatValue < 1f)
+            sync.floatValue = 0;
+        y += h;
+
+        EditorGUI.EndProperty();
+    }
+}
+
+[CustomEditor(typeof(VRCSDK2.VRC_SyncVideoStream))]
+public class SyncVideoStreamEditor : Editor
+{
+    ReorderableList sourceList;
+
+    public override void OnInspectorGUI()
+    {
+        SerializedProperty searchRoot = serializedObject.FindProperty("VideoSearchRoot");
+        EditorGUILayout.PropertyField(searchRoot);
+        SerializedProperty maxQual = serializedObject.FindProperty("MaxStreamQuality");
+        EditorGUILayout.PropertyField(maxQual);
+        SerializedProperty autoStart = serializedObject.FindProperty("AutoStart");
+        EditorGUILayout.PropertyField(autoStart);
+
+        EditorGUILayout.Space();
+
+        sourceList.DoLayoutList();
+
+        serializedObject.ApplyModifiedProperties();
+    }
+
+    private void OnEnable()
+    {
+        SerializedProperty videos = serializedObject.FindProperty("Videos");
+        sourceList = new ReorderableList(serializedObject, videos);
+        sourceList.drawElementCallback += (Rect rect, int index, bool active, bool focused) =>
+        {
+            EditorGUI.PropertyField(rect, serializedObject.FindProperty("Videos").GetArrayElementAtIndex(index));
+        };
+        sourceList.elementHeightCallback += (int index) =>
+        {
+            SerializedProperty element = serializedObject.FindProperty("Videos").GetArrayElementAtIndex(index);
+            return EditorGUI.GetPropertyHeight(element);
+        };
+        sourceList.drawHeaderCallback = (Rect rect) => EditorGUI.LabelField(rect, "Videos");
+    }
+}
+
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_SyncVideoStreamEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3f9dccfed0b072f49a307b3f20a7e768
+timeCreated: 1528745185
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_TriggerEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3aecd666943878944a811acb9db2ace7
+timeCreated: 1474315179
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_WebPanelEditor.cs

@@ -0,0 +1,216 @@
+#if VRC_SDK_VRCSDK2
+#if UNITY_EDITOR
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Build;
+using System;
+using System.Linq;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRCSDK2.VRC_WebPanel))]
+    public class VRC_WebPanelEditor : Editor
+    {
+        private void InspectorField(string propertyName, string humanName)
+        {
+            SerializedProperty propertyField = serializedObject.FindProperty(propertyName);
+            EditorGUILayout.PropertyField(propertyField, new GUIContent(humanName), true);
+        }
+        
+        bool showFiles = false;
+        System.Collections.Generic.List<string> directories = null;
+        System.Collections.Generic.List<string> files = null;
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.HelpBox("Do not play any videos with Web Panels, use VRC_SyncVideoPlayer instead!", MessageType.Error);
+
+            EditorGUILayout.Space();
+
+            InspectorField("proximity", "Proximity for Interactivity");
+            EditorGUILayout.Space();
+
+            VRCSDK2.VRC_WebPanel web = (VRCSDK2.VRC_WebPanel)target;
+
+            if (Application.isPlaying)
+            {
+                InspectorField("webRoot", "Web Root");
+                InspectorField("defaultUrl", "URI");
+
+                showFiles = web.webData != null && EditorGUILayout.Foldout(showFiles, web.webData.Count.ToString() + " files imported");
+                if (showFiles)
+                    foreach (var file in web.webData)
+                    {
+                        EditorGUILayout.BeginHorizontal();
+                        EditorGUILayout.PrefixLabel(file.path);
+                        EditorGUILayout.LabelField(file.data.Length.ToString());
+                        EditorGUILayout.EndHorizontal();
+                    }
+            }
+            else
+            {
+                SerializedProperty webRoot = serializedObject.FindProperty("webRoot");
+                RenderDirectoryList(serializedObject, "webRoot", "Path To Web Content");
+
+                if (string.IsNullOrEmpty(webRoot.stringValue))
+                {
+                    InspectorField("defaultUrl", "Start URI");
+                }
+                else
+                {
+                    RenderWebRootSelector(serializedObject, "defaultUrl", "Start Page");
+
+                    if (VRCSettings.Get().DisplayHelpBoxes)
+                    {
+                        EditorGUILayout.HelpBox("Javascript API bindings are called with engine.call('methodName', ...), which returns a promise-like object.", MessageType.Info);
+                        EditorGUILayout.HelpBox("Javascript may call ListBindings() to discover available API bindings.", MessageType.Info);
+                        EditorGUILayout.HelpBox("Javascript may listen for the 'onBindingsReady' event to execute script when the page is fully loaded and API bindings are available.", MessageType.Info);
+                    }
+                }
+            }
+
+            EditorGUILayout.Space();
+
+            InspectorField("cookiesEnabled", "Enable Cookies");
+
+            InspectorField("interactive", "Is Interactive");
+
+			InspectorField("localOnly", "Only Visible Locally");
+
+            if (!web.localOnly)
+            {
+                InspectorField("syncURI", "Synchronize URI");
+                InspectorField("syncInput", "Synchronize Mouse Position");
+            }
+
+            InspectorField("transparent", "Transparent Background");
+
+            InspectorField("autoFormSubmit", "Input should Submit Forms");
+
+            EditorGUILayout.Space();
+
+            InspectorField("station", "Interaction Station");
+            EditorGUILayout.Space();
+
+			InspectorField("cursor", "Mouse Cursor Object");
+
+            EditorGUILayout.Space();
+
+			InspectorField("resolutionWidth", "Resolution Width");
+			InspectorField("resolutionHeight", "Resolution Height");
+			InspectorField("displayRegion", "Display Region");
+
+            EditorGUILayout.Space();
+
+            InspectorField("extraVideoScreens", "Duplicate Screens");
+            
+            EditorGUILayout.EndVertical();
+
+            if (EditorGUI.EndChangeCheck())
+                serializedObject.ApplyModifiedProperties();
+        }
+
+        private void AddSubDirectories(ref System.Collections.Generic.List<string> l, string root)
+        {
+            if (!Directory.Exists(root))
+            {
+                return;
+            }
+
+            if (!root.StartsWith(Application.dataPath + Path.DirectorySeparatorChar + "VRCSDK")
+                || root == Application.dataPath + Path.DirectorySeparatorChar + "VRCSDK" + Path.DirectorySeparatorChar + "Examples" + Path.DirectorySeparatorChar + "Sample Assets" + Path.DirectorySeparatorChar + "WebRoot")
+                l.Add(root.Substring(Application.dataPath.Length));
+
+            string[] subdirectories = Directory.GetDirectories(root);
+            foreach (string dir in subdirectories)
+                AddSubDirectories(ref l, dir);
+        }
+
+        private void RenderDirectoryList(SerializedObject obj, string propertyName, string humanName)
+        {
+            if (directories == null)
+            {
+                directories = new System.Collections.Generic.List<string>();
+                directories.Add("No Web Content Directory");
+
+                AddSubDirectories(ref directories, Application.dataPath + Path.DirectorySeparatorChar);
+            }
+
+            SerializedProperty target = serializedObject.FindProperty(propertyName);
+
+            int selectedIdx = target.stringValue == null ? 0 : directories.IndexOf(target.stringValue);
+            if (selectedIdx < 0 || selectedIdx >= directories.Count)
+                selectedIdx = 0;
+
+            selectedIdx = EditorGUILayout.Popup(humanName, selectedIdx, directories.ToArray());
+            if (selectedIdx > 0 && selectedIdx < directories.Count)
+                target.stringValue = directories[selectedIdx];
+            else
+                target.stringValue = null;
+        }
+
+        private void AddSubDirectoryFiles(ref System.Collections.Generic.List<string> l, string root)
+        {
+            if (!Directory.Exists(root))
+                return;
+
+            string[] files = Directory.GetFiles(root);
+            foreach (string file in files.Where(f => f.ToLower().EndsWith(".html") || f.ToLower().EndsWith(".htm")))
+                l.Add(file.Substring(Application.dataPath.Length));
+
+            string[] subdirectories = Directory.GetDirectories(root);
+            foreach (string dir in subdirectories)
+                AddSubDirectoryFiles(ref l, dir);
+        }
+
+        private void RenderWebRootSelector(SerializedObject obj, string propertyName, string humanName)
+        {
+            SerializedProperty webRoot = obj.FindProperty("webRoot");
+            SerializedProperty target = serializedObject.FindProperty(propertyName);
+
+            if (files == null)
+            {
+                files = new System.Collections.Generic.List<string>();
+
+                AddSubDirectoryFiles(ref files, Application.dataPath + webRoot.stringValue);
+                if (files.Count == 0)
+                {
+                    EditorGUILayout.HelpBox("No suitable html files found in Web Content path.", MessageType.Error);
+                    return;
+                }
+            }
+
+            int selectedIdx = 0;
+
+            try
+            {
+                System.Uri uri = string.IsNullOrEmpty(target.stringValue) ? null : new Uri(target.stringValue);
+
+                selectedIdx = uri == null ? 0 : files.IndexOf(uri.AbsolutePath.Replace('/', System.IO.Path.DirectorySeparatorChar));
+                if (selectedIdx < 0 || selectedIdx >= files.Count)
+                    selectedIdx = 0;
+            }
+            catch { }
+
+            selectedIdx = EditorGUILayout.Popup(humanName, selectedIdx, files.ToArray());
+            if (selectedIdx >= 0 && selectedIdx < files.Count)
+            {
+                System.UriBuilder builder = new UriBuilder()
+                {
+                    Scheme = "file",
+                    Path = files[selectedIdx].Replace(System.IO.Path.DirectorySeparatorChar, '/'),
+                    Host = ""
+                };
+                target.stringValue = builder.Uri.ToString();
+            }
+        }
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_WebPanelEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d09b36020f697be4d9a0f5a6a48cfa83
+timeCreated: 1457992191
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_YouTubeSyncEditor.cs

@@ -0,0 +1,20 @@
+#if UNITY_EDITOR && VRC_SDK_VRCSDK2
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRC_YouTubeSync))]
+	public class VRC_YouTubeSyncEditor : Editor
+    {
+		public override void OnInspectorGUI()
+		{
+            EditorGUILayout.HelpBox("This component is deprecated, please use the VRC_SyncVideoPlayer component instead.", MessageType.Error);
+		}
+	} 
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components/VRC_YouTubeSyncEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 764e26c1ca28e2e45a30c778c1955a47
+timeCreated: 1474675311
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 92a4896241003fe4a8fc71eeb5c7268d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCDestructibleUdonEditor.cs

@@ -0,0 +1,59 @@
+/*
+#if VRC_SDK_VRCSDK3
+
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using System;
+
+[CustomEditor(typeof(VRC.SDK3.Components.VRCDestructibleUdon))]
+public class VRCDestructibleUdonEditor : Editor
+{
+	VRC.SDK3.Components.VRCDestructibleUdon myTarget;
+
+	void OnEnable()
+	{
+		if (myTarget == null)
+			myTarget = (VRC.SDK3.Components.VRCDestructibleUdon)target;
+	}
+
+	string[] UdonMethods = null;
+	string[] UdonVariables = null;
+
+	public override void OnInspectorGUI()
+	{
+		var udon = myTarget.GetComponent<VRC.Udon.UdonBehaviour>();
+		if (udon != null)
+		{
+			#if VRC_CLIENT
+				myTarget.UdonMethodApplyDamage = EditorGUILayout.TextField("On Apply Damage", myTarget.UdonMethodApplyDamage);
+				myTarget.UdonMethodApplyHealing= EditorGUILayout.TextField("On Apply Healing", myTarget.UdonMethodApplyHealing);
+				myTarget.UdonVariableCurrentHealth= EditorGUILayout.TextField("Current Health Variable", myTarget.UdonVariableCurrentHealth);
+				myTarget.UdonVariableMaxHealth = EditorGUILayout.TextField("On Max Health Variable", myTarget.UdonVariableMaxHealth);
+			#else
+				List<string> methods = new List<string>(udon.GetPrograms());
+				methods.Insert(0, "-none-");
+				myTarget.UdonMethodApplyDamage = DrawUdonProgramPicker("On Apply Damage", myTarget.UdonMethodApplyDamage, methods);
+				myTarget.UdonMethodApplyHealing = DrawUdonProgramPicker("On Apply Healing", myTarget.UdonMethodApplyHealing, methods);
+				List<string> variables = new List<string>(udon.publicVariables.VariableSymbols);
+				variables.Insert(0, "-none-");
+				myTarget.UdonVariableCurrentHealth = DrawUdonProgramPicker("Current Health Variable", myTarget.UdonVariableCurrentHealth, variables);
+				myTarget.UdonVariableMaxHealth = DrawUdonProgramPicker("Max Health Variable", myTarget.UdonVariableMaxHealth, variables);
+			#endif
+		}
+	}
+
+	string DrawUdonProgramPicker(string title, string current, List<string> choices)
+	{
+		int index = choices.IndexOf(current);
+		if (index == -1)
+			index = 0;
+		int value = EditorGUILayout.Popup(title, index, choices.ToArray());
+		if (value != 0)
+			return choices[value];
+		return current;
+	}
+}
+#endif
+*/

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCDestructibleUdonEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d57b23c04034119448f23c5fdbc57662
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCPlayerStationEditor3.cs

@@ -0,0 +1,33 @@
+#if VRC_SDK_VRCSDK3
+
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using System;
+
+[CustomEditor(typeof(VRC.SDK3.Components.VRCStation))]
+public class VRCPlayerStationEditor3 : Editor 
+{
+    VRC.SDK3.Components.VRCStation myTarget;
+
+	void OnEnable()
+	{
+		if(myTarget == null)
+			myTarget = (VRC.SDK3.Components.VRCStation)target;
+	}
+
+	public override void OnInspectorGUI()
+	{
+		myTarget.PlayerMobility = (VRC.SDKBase.VRCStation.Mobility)EditorGUILayout.EnumPopup("Player Mobility", myTarget.PlayerMobility);
+		myTarget.canUseStationFromStation = EditorGUILayout.Toggle("Can Use Station From Station", myTarget.canUseStationFromStation);
+		myTarget.animatorController = (RuntimeAnimatorController) EditorGUILayout.ObjectField("Animator Controller", myTarget.animatorController, typeof(RuntimeAnimatorController), false );
+		myTarget.disableStationExit = EditorGUILayout.Toggle("Disable Station Exit", myTarget.disableStationExit );
+		myTarget.seated = EditorGUILayout.Toggle("Seated", myTarget.seated);
+		myTarget.stationEnterPlayerLocation = (Transform)EditorGUILayout.ObjectField("Player Enter Location", myTarget.stationEnterPlayerLocation, typeof(Transform), true);
+		myTarget.stationExitPlayerLocation = (Transform)EditorGUILayout.ObjectField("Player Exit Location", myTarget.stationExitPlayerLocation, typeof(Transform), true);
+		myTarget.controlsObject = (VRC.SDKBase.VRC_ObjectApi)EditorGUILayout.ObjectField("API Object", myTarget.controlsObject, typeof(VRC.SDKBase.VRC_ObjectApi), false);
+	}
+	
+}
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCPlayerStationEditor3.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8901d07a685ca424492a3cabff506184
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCSceneDescriptorEditor3.cs

@@ -0,0 +1,27 @@
+#if VRC_SDK_VRCSDK3
+
+using UnityEditor;
+
+[CustomEditor (typeof(VRC.SDK3.Components.VRCSceneDescriptor))]
+public class VRCSceneDescriptorEditor3 : Editor
+{
+    VRC.SDK3.Components.VRCSceneDescriptor sceneDescriptor;
+    VRC.Core.PipelineManager pipelineManager;
+
+    public override void OnInspectorGUI()
+    {
+        if(sceneDescriptor == null)
+            sceneDescriptor = (VRC.SDK3.Components.VRCSceneDescriptor)target;
+
+        if(pipelineManager == null)
+        {
+            pipelineManager = sceneDescriptor.GetComponent<VRC.Core.PipelineManager>();
+            if(pipelineManager == null)
+                sceneDescriptor.gameObject.AddComponent<VRC.Core.PipelineManager>();
+        }
+
+        DrawDefaultInspector();
+    }
+}
+
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRCSceneDescriptorEditor3.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4b2b9ac625bc5b04c887ff9ee9b5fdbe
+timeCreated: 1450463561
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRC_PickupEditor3.cs

@@ -0,0 +1,73 @@
+#if VRC_SDK_VRCSDK3
+#if UNITY_EDITOR
+
+using UnityEditor;
+using UnityEngine;
+
+namespace VRCSDK2
+{
+    [CustomEditor(typeof(VRC.SDK3.Components.VRCPickup))]
+    public class VRC_PickupEditor3 : Editor
+    {
+        private void InspectorField(string propertyName, string humanName)
+        {
+            SerializedProperty propertyField = serializedObject.FindProperty(propertyName);
+            EditorGUILayout.PropertyField(propertyField, new GUIContent(humanName), true);
+        }
+
+        private SerializedProperty momentumTransferMethodProperty;
+        private SerializedProperty disallowTheftProperty;
+        private SerializedProperty exactGunProperty;
+        private SerializedProperty exactGripProperty;
+        private SerializedProperty allowManipulationWhenEquippedProperty;
+        private SerializedProperty orientationProperty;
+        private SerializedProperty autoHoldProperty;
+        private SerializedProperty interactionTextProperty;
+        private SerializedProperty useTextProperty;
+        private SerializedProperty throwVelocityBoostMinSpeedProperty;
+        private SerializedProperty throwVelocityBoostScaleProperty;
+        private SerializedProperty pickupableProperty;
+        private SerializedProperty proximityProperty;
+
+        public override void OnInspectorGUI()
+        {
+            momentumTransferMethodProperty = serializedObject.FindProperty("MomentumTransferMethod");
+            disallowTheftProperty = serializedObject.FindProperty("DisallowTheft");
+            exactGunProperty = serializedObject.FindProperty("ExactGun");
+            exactGripProperty = serializedObject.FindProperty("ExactGrip");
+            allowManipulationWhenEquippedProperty = serializedObject.FindProperty("allowManipulationWhenEquipped");
+            orientationProperty = serializedObject.FindProperty("orientation");
+            autoHoldProperty = serializedObject.FindProperty("AutoHold");
+            interactionTextProperty = serializedObject.FindProperty("InteractionText");
+            useTextProperty = serializedObject.FindProperty("UseText");
+            throwVelocityBoostMinSpeedProperty = serializedObject.FindProperty("ThrowVelocityBoostMinSpeed");
+            throwVelocityBoostScaleProperty = serializedObject.FindProperty("ThrowVelocityBoostScale");
+            pickupableProperty = serializedObject.FindProperty("pickupable");
+            proximityProperty = serializedObject.FindProperty("proximity");
+
+            EditorGUILayout.BeginVertical(GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 30));
+
+            EditorGUILayout.PropertyField(momentumTransferMethodProperty, new GUIContent("Momentum Transfer Method"));
+            EditorGUILayout.PropertyField(disallowTheftProperty, new GUIContent("Disallow Theft"));
+            EditorGUILayout.PropertyField(exactGunProperty, new GUIContent("Exact Gun"));
+            EditorGUILayout.PropertyField(exactGripProperty, new GUIContent("Exact Grip"));
+            EditorGUILayout.PropertyField(allowManipulationWhenEquippedProperty, new GUIContent("Allow Manipulation When Equipped"));
+            EditorGUILayout.PropertyField(orientationProperty, new GUIContent("Orientation"));
+            EditorGUILayout.PropertyField(autoHoldProperty, new GUIContent("AutoHold", "If the pickup is supposed to be aligned to the hand (i.e. orientation field is set to Gun or Grip), auto-detect means that it will be Equipped(not dropped when they release trigger),  otherwise just hold as a normal pickup."));
+            EditorGUILayout.PropertyField(interactionTextProperty, new GUIContent("Interaction Text","Text displayed when user hovers over the pickup."));
+            if (autoHoldProperty.enumValueIndex != (int)VRC.SDK3.Components.VRCPickup.AutoHoldMode.No)
+                EditorGUILayout.PropertyField(useTextProperty, new GUIContent("Use Text", "Text to display describing action for clicking button, when this pickup is already being held."));
+            EditorGUILayout.PropertyField(throwVelocityBoostMinSpeedProperty, new GUIContent("Throw Velocity Boost Min Speed"));
+            EditorGUILayout.PropertyField(throwVelocityBoostScaleProperty, new GUIContent("Throw Velocity Boost Scale"));
+            EditorGUILayout.PropertyField(pickupableProperty, new GUIContent("Pickupable"));
+            EditorGUILayout.PropertyField(proximityProperty, new GUIContent("Proximity"));
+
+            EditorGUILayout.EndVertical();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRC_PickupEditor3.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a8cc4c1876b26174fbaeb062178a6bda
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRC_SpatialAudioSourceEditor3.cs

@@ -0,0 +1,58 @@
+#if VRC_SDK_VRCSDK3
+#if UNITY_EDITOR
+
+using UnityEngine;
+using UnityEditor;
+
+namespace VRC.SDK3.Editor
+{
+    [CustomEditor(typeof(VRC.SDK3.Components.VRCSpatialAudioSource))]
+    public class VRC_SpatialAudioSourceEditor3 : UnityEditor.Editor
+    {
+        private bool showAdvancedOptions = false;
+        private SerializedProperty gainProperty;
+        private SerializedProperty nearProperty;
+        private SerializedProperty farProperty;
+        private SerializedProperty volRadiusProperty;
+        private SerializedProperty enableSpatialProperty;
+        private SerializedProperty useCurveProperty;
+
+        public override void OnInspectorGUI()
+        {
+            gainProperty = serializedObject.FindProperty("Gain");
+            nearProperty = serializedObject.FindProperty("Near");
+            farProperty = serializedObject.FindProperty("Far");
+            volRadiusProperty = serializedObject.FindProperty("VolumetricRadius");
+            enableSpatialProperty = serializedObject.FindProperty("EnableSpatialization");
+            useCurveProperty = serializedObject.FindProperty("UseAudioSourceVolumeCurve");
+
+            serializedObject.Update();
+
+            VRC.SDKBase.VRC_SpatialAudioSource target = serializedObject.targetObject as VRC.SDKBase.VRC_SpatialAudioSource;
+            AudioSource source = target.GetComponent<AudioSource>();
+
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(gainProperty, new GUIContent("Gain"));
+            EditorGUILayout.PropertyField(farProperty, new GUIContent("Far"));
+            showAdvancedOptions = EditorGUILayout.Foldout(showAdvancedOptions, "Advanced Options");
+            bool enableSp = enableSpatialProperty.boolValue;
+            if (showAdvancedOptions)
+            {
+                EditorGUILayout.PropertyField(nearProperty, new GUIContent("Near"));
+                EditorGUILayout.PropertyField(volRadiusProperty, new GUIContent("Volumetric Radius"));
+                EditorGUILayout.PropertyField(enableSpatialProperty, new GUIContent("Enable Spatialization"));
+                if (enableSp)
+                    EditorGUILayout.PropertyField(useCurveProperty, new GUIContent("Use AudioSource Volume Curve"));
+            }
+
+            EditorGUILayout.EndVertical();
+
+            if (source != null)
+                source.spatialize = enableSp;
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+#endif
+#endif

Assets/VRCSDK/Dependencies/VRChat/Editor/Components3/VRC_SpatialAudioSourceEditor3.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3f8f999a8e1ebee4588f94a8a618d7c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6a7071a2aea77fb48bfbe2492a2f911e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/IVRCSdkControlPanelBuilder.cs

@@ -0,0 +1,9 @@
+
+public interface IVRCSdkControlPanelBuilder
+{
+    void ShowSettingsOptions();
+    bool IsValidBuilder(out string message);
+    void ShowBuilder();
+    void RegisterBuilder(VRCSdkControlPanel baseBuilder);
+    void SelectAllComponents();
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/IVRCSdkControlPanelBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 310a760e312f2984e85eece367bab19a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanel.cs

@@ -0,0 +1,246 @@
+using UnityEditor;
+using UnityEngine;
+using VRC.Core;
+
+[ExecuteInEditMode]
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    public static VRCSdkControlPanel window;
+
+    [MenuItem("VRChat SDK/Show Control Panel", false, 600)]
+    static void ShowControlPanel()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+        {
+            VRC.Core.API.SetOnlineMode(true, "vrchat");
+            ConfigManager.RemoteConfig.Init(() => ShowControlPanel());
+            return;
+        }
+
+        window = (VRCSdkControlPanel)EditorWindow.GetWindow(typeof(VRCSdkControlPanel));
+        window.titleContent.text = "VRChat SDK";
+        window.minSize = new Vector2(SdkWindowWidth + 4, 600);
+        window.maxSize = new Vector2(SdkWindowWidth + 4, 2000);
+        window.Init();
+        window.Show();
+    }
+
+    void Update()
+    {
+        Repaint();
+    }
+
+    public static GUIStyle titleGuiStyle;
+    public static GUIStyle boxGuiStyle;
+    public static GUIStyle infoGuiStyle;
+    public static GUIStyle listButtonStyleEven;
+    public static GUIStyle listButtonStyleOdd;
+    public static GUIStyle listButtonStyleSelected;
+    public static GUIStyle scrollViewSeparatorStyle;
+    public static GUIStyle searchBarStyle;
+
+    void InitializeStyles()
+    {
+        titleGuiStyle = new GUIStyle();
+        titleGuiStyle.fontSize = 15;
+        titleGuiStyle.fontStyle = FontStyle.BoldAndItalic;
+        titleGuiStyle.alignment = TextAnchor.MiddleCenter;
+        titleGuiStyle.wordWrap = true;
+        if (EditorGUIUtility.isProSkin)
+            titleGuiStyle.normal.textColor = Color.white;
+        else
+            titleGuiStyle.normal.textColor = Color.black;
+
+        boxGuiStyle = new GUIStyle();
+        if (EditorGUIUtility.isProSkin)
+        {
+            boxGuiStyle.normal.background = CreateBackgroundColorImage(new Color(0.3f, 0.3f, 0.3f));
+            boxGuiStyle.normal.textColor = Color.white;
+        }
+        else
+        {
+            boxGuiStyle.normal.background = CreateBackgroundColorImage(new Color(0.85f, 0.85f, 0.85f));
+            boxGuiStyle.normal.textColor = Color.black;
+        }
+
+        infoGuiStyle = new GUIStyle();
+        infoGuiStyle.wordWrap = true; ;
+        if (EditorGUIUtility.isProSkin)
+            infoGuiStyle.normal.textColor = Color.white;
+        else
+            infoGuiStyle.normal.textColor = Color.black;
+        infoGuiStyle.margin = new RectOffset(10, 10, 10, 10);
+
+        listButtonStyleEven = new GUIStyle();
+        listButtonStyleEven.margin = new RectOffset(0, 0, 0, 0);
+        listButtonStyleEven.border = new RectOffset(0, 0, 0, 0);
+        if (EditorGUIUtility.isProSkin)
+        {
+            listButtonStyleEven.normal.textColor = new Color(0.8f, 0.8f, 0.8f);
+            listButtonStyleEven.normal.background = CreateBackgroundColorImage(new Color(0.540f, 0.540f, 0.54f));
+        }
+        else
+        {
+            listButtonStyleEven.normal.textColor = Color.black;
+            listButtonStyleEven.normal.background = CreateBackgroundColorImage(new Color(0.85f, 0.85f, 0.85f));
+        }
+
+        listButtonStyleOdd = new GUIStyle();
+        listButtonStyleOdd.margin = new RectOffset(0, 0, 0, 0);
+        listButtonStyleOdd.border = new RectOffset(0, 0, 0, 0);
+        if (EditorGUIUtility.isProSkin)
+        {
+            listButtonStyleOdd.normal.textColor = new Color(0.8f, 0.8f, 0.8f);
+            //listButtonStyleOdd.normal.background = CreateBackgroundColorImage(new Color(0.50f, 0.50f, 0.50f));
+        }
+        else
+        {
+            listButtonStyleOdd.normal.textColor = Color.black;
+            listButtonStyleOdd.normal.background = CreateBackgroundColorImage(new Color(0.90f, 0.90f, 0.90f));
+        }
+
+        listButtonStyleSelected = new GUIStyle();
+        listButtonStyleSelected.normal.textColor = Color.white;
+        listButtonStyleSelected.margin = new RectOffset(0, 0, 0, 0);
+        if (EditorGUIUtility.isProSkin)
+        {
+            listButtonStyleSelected.normal.textColor = new Color(0.8f, 0.8f, 0.8f);
+            listButtonStyleSelected.normal.background = CreateBackgroundColorImage(new Color(0.4f, 0.4f, 0.4f));
+        }
+        else
+        {
+            listButtonStyleSelected.normal.textColor = Color.black;
+            listButtonStyleSelected.normal.background = CreateBackgroundColorImage(new Color(0.75f, 0.75f, 0.75f));
+        }
+
+        scrollViewSeparatorStyle = new GUIStyle("Toolbar");
+        scrollViewSeparatorStyle.fixedWidth = SdkWindowWidth + 10;
+        scrollViewSeparatorStyle.fixedHeight = 4;
+        scrollViewSeparatorStyle.margin.top = 1;
+
+        searchBarStyle = new GUIStyle("Toolbar");
+        searchBarStyle.fixedWidth = SdkWindowWidth;
+        searchBarStyle.fixedHeight = 23;
+        searchBarStyle.padding.top = 3;
+
+    }
+
+    void Init()
+    {
+        InitializeStyles();
+        ResetIssues();
+        InitAccount();
+    }
+
+    void OnEnable()
+    {
+        OnEnableAccount();
+        AssemblyReloadEvents.afterAssemblyReload += BuilderAssemblyReload;
+    }
+
+    void OnDisable()
+    {
+        AssemblyReloadEvents.afterAssemblyReload -= BuilderAssemblyReload;
+    }
+
+    void OnDestroy()
+    {
+        AccountDestroy();
+    }
+
+    public const int SdkWindowWidth = 518;
+
+    void OnGUI()
+    {
+        if (window == null)
+        {
+            window = (VRCSdkControlPanel)EditorWindow.GetWindow(typeof(VRCSdkControlPanel));
+            InitializeStyles();
+        }
+
+        if (_bannerImage == null)
+            _bannerImage = AssetDatabase.LoadAssetAtPath("Assets/VRCSDK/Dependencies/VRChat/SdkGraphics/SDK_Panel_Banner.png", typeof(Texture2D)) as Texture2D;
+
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.BeginVertical();
+
+        GUILayout.Box(_bannerImage);
+
+        if (Application.isPlaying)
+        {
+            GUI.enabled = false;
+            GUILayout.Space(20);
+            EditorGUILayout.LabelField("Unity Application is running ...\nStop it to access the Control Panel", titleGuiStyle, GUILayout.Width(SdkWindowWidth));
+            GUI.enabled = true;
+            GUILayout.EndVertical();
+            GUILayout.FlexibleSpace();
+            GUILayout.EndHorizontal();
+            return;
+        }
+
+        EditorGUILayout.Space();
+
+        EnvConfig.SetActiveSDKDefines();
+
+        #if VRC_SDK_VRCSDK2
+            VRCSettings.Get().activeWindowPanel = GUILayout.Toolbar(VRCSettings.Get().activeWindowPanel, new string[] { "Authentication", "Builder", "Content Manager", "Settings" }, GUILayout.Width(SdkWindowWidth));
+            int showPanel = VRCSettings.Get().activeWindowPanel;
+        #elif VRC_SDK_VRCSDK3
+            VRC.SDK3.Editor.VRCSettings.Get().activeWindowPanel = GUILayout.Toolbar(VRC.SDK3.Editor.VRCSettings.Get().activeWindowPanel, new string[] { "Authentication", "Builder", "Content Manager", "Settings" }, GUILayout.Width(SdkWindowWidth));
+            int showPanel = VRC.SDK3.Editor.VRCSettings.Get().activeWindowPanel;
+        #else
+            int showPanel = 0;
+        #endif
+
+        GUILayout.EndVertical();
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+
+        if (APIUser.IsLoggedInWithCredentials == false && showPanel != 3)
+            showPanel = 0;
+
+        switch (showPanel)
+        {
+            case 1:
+                ShowBuilders();
+                break;
+            case 2:
+                ShowContent();
+                break;
+            case 3:
+                ShowSettings();
+                break;
+            case 0:
+            default:
+                ShowAccount();
+                break;
+        }
+    }
+
+    [UnityEditor.Callbacks.PostProcessScene]
+    static void OnPostProcessScene()
+    {
+        if (window != null)
+            window.Reset();
+    }
+
+    private void OnFocus()
+    {
+        Reset();
+    }
+
+    public void Reset()
+    {
+        ResetIssues();
+        // style backgrounds may be nulled on scene load. detect if so has happened
+        if((boxGuiStyle != null) && (boxGuiStyle.normal.background == null))
+            InitializeStyles();
+    }
+
+    [UnityEditor.Callbacks.DidReloadScripts(int.MaxValue)]
+    static void DidReloadScripts()
+    {
+        RefreshApiUrlSetting();
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanel.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 20b4cdbdda9655947aab6f8f2c90690f
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelAccount.cs

@@ -0,0 +1,594 @@
+using UnityEngine;
+using UnityEditor;
+using VRC.Core;
+using System.Text.RegularExpressions;
+
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    static bool isInitialized = false;
+    static string clientInstallPath;
+    static bool signingIn = false;
+    static string error = null;
+
+    public static bool FutureProofPublishEnabled { get { return UnityEditor.EditorPrefs.GetBool("futureProofPublish", DefaultFutureProofPublishEnabled); } }
+    //public static bool DefaultFutureProofPublishEnabled { get { return !SDKClientUtilities.IsInternalSDK(); } }
+    public static bool DefaultFutureProofPublishEnabled { get { return true; } }
+
+    static string storedUsername
+    {
+        get
+        {
+            if (EditorPrefs.HasKey("sdk#username"))
+                return EditorPrefs.GetString("sdk#username");
+            return null;
+        }
+        set
+        {
+            EditorPrefs.SetString("sdk#username", value);
+            if (string.IsNullOrEmpty(value))
+                EditorPrefs.DeleteKey("sdk#username");
+        }
+    }
+
+    static string storedPassword
+    {
+        get
+        {
+            if (EditorPrefs.HasKey("sdk#password"))
+                return EditorPrefs.GetString("sdk#password");
+            return null;
+        }
+        set
+        {
+            EditorPrefs.SetString("sdk#password", value);
+            if (string.IsNullOrEmpty(value))
+                EditorPrefs.DeleteKey("sdk#password");
+        }
+    }
+
+    static string _username = null;
+    static string _password = null;
+
+    static string username
+    {
+        get
+        {
+            if (!string.IsNullOrEmpty(_username))
+                return _username;
+            else
+                _username = storedUsername;
+            return _username;
+        }
+        set
+        {
+            _username = value;
+        }
+    }
+
+    static string password
+    {
+        get
+        {
+            if (!string.IsNullOrEmpty(_password))
+                return _password;
+            else
+                _password = storedPassword;
+            return _password;
+        }
+        set
+        {
+            _password = value;
+        }
+    }
+
+    static ApiServerEnvironment serverEnvironment
+    {
+        get
+        {
+            ApiServerEnvironment env = ApiServerEnvironment.Release;
+            try
+            {
+                env = (ApiServerEnvironment)System.Enum.Parse(typeof(ApiServerEnvironment), UnityEditor.EditorPrefs.GetString("VRC_ApiServerEnvironment", env.ToString()));
+            }
+            catch (System.Exception e)
+            {
+                Debug.LogError("Invalid server environment name - " + e.ToString());
+            }
+
+            return env;
+        }
+        set
+        {
+            UnityEditor.EditorPrefs.SetString("VRC_ApiServerEnvironment", value.ToString());
+
+            API.SetApiUrlFromEnvironment(value);
+        }
+    }
+
+    private void OnEnableAccount()
+    {
+        entered2faCodeIsInvalid = false;
+        warningIconGraphic = Resources.Load("2FAIcons/SDK_Warning_Triangle_icon") as Texture2D;
+    }
+
+    public static void RefreshApiUrlSetting()
+    {
+        // this forces the static api url variable to be reset from the server environment set in editor prefs.
+        // needed because the static variable states get cleared when entering / exiting play mode
+        ApiServerEnvironment env = serverEnvironment;
+        serverEnvironment = env;
+    }
+
+    public static void InitAccount()
+    {
+        if (isInitialized)
+            return;
+
+        if (!APIUser.IsLoggedInWithCredentials && ApiCredentials.Load())
+            APIUser.FetchCurrentUser((c) => AnalyticsSDK.LoggedInUserChanged(c.Model as APIUser), null);
+
+        clientInstallPath = SDKClientUtilities.GetSavedVRCInstallPath();
+        if (string.IsNullOrEmpty(clientInstallPath))
+            clientInstallPath = SDKClientUtilities.LoadRegistryVRCInstallPath();
+
+        signingIn = false;
+        isInitialized = true;
+
+        ClearContent();
+    }
+
+    public static bool OnShowStatus()
+    {
+        API.SetOnlineMode(true);
+
+        SignIn(false);
+
+        EditorGUILayout.BeginVertical();
+
+        if (APIUser.IsLoggedInWithCredentials)
+        {
+            OnCreatorStatusGUI();
+        }
+
+        EditorGUILayout.EndVertical();
+
+        return APIUser.IsLoggedInWithCredentials;
+    }
+
+    static bool OnAccountGUI()
+    {
+        const int ACCOUNT_LOGIN_BORDER_SPACING = 20;
+
+        EditorGUILayout.Separator();
+        EditorGUILayout.Separator();
+        EditorGUILayout.Separator();
+        EditorGUILayout.Separator();
+
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.Space(ACCOUNT_LOGIN_BORDER_SPACING);
+        GUILayout.BeginVertical("Account", "window", GUILayout.Height(150), GUILayout.Width(340));
+
+        if (signingIn)
+        {
+            EditorGUILayout.LabelField("Signing in as " + username + ".");
+        }
+        else if (APIUser.IsLoggedInWithCredentials)
+        {
+            if (Status != "Connected")
+                EditorGUILayout.LabelField(Status);
+
+            OnCreatorStatusGUI();
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("");
+
+            if (GUILayout.Button("Logout"))
+            {
+                storedUsername = username = null;
+                storedPassword = password = null;
+
+                VRC.Tools.ClearCookies();
+                APIUser.Logout();
+                ClearContent();
+            }
+            GUILayout.EndHorizontal();
+        }
+        else
+        {
+            InitAccount();
+
+            ApiServerEnvironment newEnv = ApiServerEnvironment.Release;
+            #if VRC_SDK_VRCSDK2
+                if (VRCSettings.Get().DisplayAdvancedSettings)
+                    newEnv = (ApiServerEnvironment)EditorGUILayout.EnumPopup("Use API", serverEnvironment);
+            #elif VRC_SDK_VRCSDK3
+                if (VRC.SDK3.Editor.VRCSettings.Get().DisplayAdvancedSettings)
+                    newEnv = (ApiServerEnvironment)EditorGUILayout.EnumPopup("Use API", serverEnvironment);
+            #endif
+            if (serverEnvironment != newEnv)
+                serverEnvironment = newEnv;
+
+            username = EditorGUILayout.TextField("Username", username);
+            password = EditorGUILayout.PasswordField("Password", password);
+
+            if (GUILayout.Button("Sign In"))
+                SignIn(true);
+            if (GUILayout.Button("Sign up"))
+                Application.OpenURL("http://vrchat.com/register");
+        }
+
+        if (showTwoFactorAuthenticationEntry)
+        {
+            OnTwoFactorAuthenticationGUI();
+        }
+
+        GUILayout.EndVertical();
+        GUILayout.Space(ACCOUNT_LOGIN_BORDER_SPACING);
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+
+        return !signingIn;
+    }
+
+    static void OnCreatorStatusGUI()
+    {
+        EditorGUILayout.LabelField("Logged in as:", APIUser.CurrentUser.displayName);
+
+        //if (SDKClientUtilities.IsInternalSDK())
+        //    EditorGUILayout.LabelField("Developer Status: ", APIUser.CurrentUser.developerType.ToString());
+
+        EditorGUILayout.BeginHorizontal();
+
+        EditorGUILayout.BeginVertical();
+        EditorGUILayout.LabelField("World Creator Status: ", APIUser.CurrentUser.canPublishWorlds ? "Allowed to publish worlds" : "Not yet allowed to publish worlds");
+        EditorGUILayout.LabelField("Avatar Creator Status: ", APIUser.CurrentUser.canPublishAvatars ? "Allowed to publish avatars" : "Not yet allowed to publish avatars");
+        EditorGUILayout.EndVertical();
+
+        if (!APIUser.CurrentUser.canPublishAllContent)
+        {
+            if (GUILayout.Button("More Info..."))
+            {
+                VRCSdkControlPanel.ShowContentPublishPermissionsDialog();
+            }
+        }
+
+
+        EditorGUILayout.EndHorizontal();
+    }
+
+    void ShowAccount()
+    {
+        if (VRC.Core.ConfigManager.RemoteConfig.IsInitialized())
+        {
+            if (VRC.Core.ConfigManager.RemoteConfig.HasKey("sdkUnityVersion"))
+            {
+                string sdkUnityVersion = VRC.Core.ConfigManager.RemoteConfig.GetString("sdkUnityVersion");
+                if (string.IsNullOrEmpty(sdkUnityVersion))
+                    EditorGUILayout.LabelField("Could not fetch remote config.");
+                else if (Application.unityVersion != sdkUnityVersion)
+                {
+                    EditorGUILayout.LabelField("Unity Version", EditorStyles.boldLabel);
+                    EditorGUILayout.LabelField("Wrong Unity version. Please use " + sdkUnityVersion);
+                }
+            }
+        }
+        else
+        {
+            VRC.Core.API.SetOnlineMode(true, "vrchat");
+            VRC.Core.ConfigManager.RemoteConfig.Init();
+        }
+
+        OnAccountGUI();
+    }
+
+
+    private const string TWO_FACTOR_AUTHENTICATION_HELP_URL = "https://docs.vrchat.com/docs/setup-2fa";
+
+    private const string ENTER_2FA_CODE_TITLE_STRING = "Enter a numeric code from your authenticator app (or one of your saved recovery codes).";
+    private const string ENTER_2FA_CODE_LABEL_STRING = "Code:";
+
+    private const string CHECKING_2FA_CODE_STRING = "Checking code...";
+    private const string ENTER_2FA_CODE_INVALID_CODE_STRING = "Invalid Code";
+
+    private const string ENTER_2FA_CODE_VERIFY_STRING = "Verify";
+    private const string ENTER_2FA_CODE_CANCEL_STRING = "Cancel";
+    private const string ENTER_2FA_CODE_HELP_STRING = "Help";
+
+    private const int WARNING_ICON_SIZE = 60;
+    private const int WARNING_FONT_HEIGHT = 18;
+
+    static private Texture2D warningIconGraphic;
+
+    static bool entered2faCodeIsInvalid;
+    static bool authorizationCodeWasVerified;
+
+    static private int previousAuthenticationCodeLength = 0;
+    static bool checkingCode;
+    static string authenticationCode = "";
+
+    static System.Action onAuthenticationVerifiedAction;
+
+    static bool _showTwoFactorAuthenticationEntry = false;
+
+    static bool showTwoFactorAuthenticationEntry
+    {
+        get
+        {
+            return _showTwoFactorAuthenticationEntry;
+        }
+        set
+        {
+            _showTwoFactorAuthenticationEntry = value;
+            authenticationCode = "";
+            if (!_showTwoFactorAuthenticationEntry && !authorizationCodeWasVerified)
+                Logout();
+        }
+    }
+
+    static bool IsValidAuthenticationCodeFormat()
+    {
+        bool isValid2faAuthenticationCode = false;
+
+        if (!string.IsNullOrEmpty(authenticationCode))
+        {
+            // check if the input is a valid 6-digit numberic code (ignoring spaces)
+            Regex rx = new Regex(@"^(\s*\d\s*){6}$", RegexOptions.Compiled);
+            MatchCollection matches6DigitCode = rx.Matches(authenticationCode);
+            isValid2faAuthenticationCode = (matches6DigitCode.Count == 1);
+        }
+
+        return isValid2faAuthenticationCode;
+    }
+
+    static bool IsValidRecoveryCodeFormat()
+    {
+        bool isValid2faRecoveryCode = false;
+
+        if (!string.IsNullOrEmpty(authenticationCode))
+        {
+            // check if the input is a valid 8-digit alpha-numberic code (format xxxx-xxxx) "-" is optional & ignore any spaces
+            // OTP codes also exclude the letters i,l,o and the digit 1 to prevent any confusion
+            Regex rx = new Regex(@"^(\s*[a-hj-km-np-zA-HJ-KM-NP-Z02-9]\s*){4}-?(\s*[a-hj-km-np-zA-HJ-KM-NP-Z02-9]\s*){4}$", RegexOptions.Compiled);
+            MatchCollection matchesRecoveryCode = rx.Matches(authenticationCode);
+            isValid2faRecoveryCode = (matchesRecoveryCode.Count == 1);
+        }
+
+        return isValid2faRecoveryCode;
+    }
+
+    static void OnTwoFactorAuthenticationGUI()
+    {
+        const int ENTER_2FA_CODE_BORDER_SIZE = 20;
+        const int ENTER_2FA_CODE_BUTTON_WIDTH = 260;
+        const int ENTER_2FA_CODE_VERIFY_BUTTON_WIDTH = ENTER_2FA_CODE_BUTTON_WIDTH / 2;
+        const int ENTER_2FA_CODE_ENTRY_REGION_WIDTH = 130;
+        const int ENTER_2FA_CODE_MIN_WINDOW_WIDTH = ENTER_2FA_CODE_VERIFY_BUTTON_WIDTH + ENTER_2FA_CODE_ENTRY_REGION_WIDTH + (ENTER_2FA_CODE_BORDER_SIZE * 3);
+
+        bool isValidAuthenticationCode = IsValidAuthenticationCodeFormat();
+
+
+        // Invalid code text
+        if (entered2faCodeIsInvalid)
+        {
+            GUIStyle s = new GUIStyle(EditorStyles.label);
+            s.alignment = TextAnchor.UpperLeft;
+            s.normal.textColor = Color.red;
+            s.fontSize = WARNING_FONT_HEIGHT;
+            s.padding = new RectOffset(0, 0, (WARNING_ICON_SIZE - s.fontSize) / 2, 0);
+            s.fixedHeight = WARNING_ICON_SIZE;
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+
+            EditorGUILayout.BeginVertical();
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.BeginHorizontal();
+            var textDimensions = s.CalcSize(new GUIContent(ENTER_2FA_CODE_INVALID_CODE_STRING));
+            GUILayout.Label(new GUIContent(warningIconGraphic), GUILayout.Width(WARNING_ICON_SIZE), GUILayout.Height(WARNING_ICON_SIZE));
+            EditorGUILayout.LabelField(ENTER_2FA_CODE_INVALID_CODE_STRING, s, GUILayout.Width(textDimensions.x));
+            EditorGUILayout.EndHorizontal();
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndVertical();
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+        else if (checkingCode)
+        {
+            // Display checking code message
+            EditorGUILayout.BeginVertical();
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.BeginHorizontal();
+            GUIStyle s = new GUIStyle(EditorStyles.label);
+            s.alignment = TextAnchor.MiddleCenter;
+            s.fixedHeight = WARNING_ICON_SIZE;
+            EditorGUILayout.LabelField(CHECKING_2FA_CODE_STRING, s, GUILayout.Height(WARNING_ICON_SIZE));
+            EditorGUILayout.EndHorizontal();
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndVertical();
+        }
+        else
+        {
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(ENTER_2FA_CODE_BORDER_SIZE);
+            GUILayout.FlexibleSpace();
+            GUIStyle titleStyle = new GUIStyle(EditorStyles.label);
+            titleStyle.alignment = TextAnchor.MiddleCenter;
+            titleStyle.wordWrap = true;
+            EditorGUILayout.LabelField(ENTER_2FA_CODE_TITLE_STRING, titleStyle, GUILayout.Width(ENTER_2FA_CODE_MIN_WINDOW_WIDTH - (2 * ENTER_2FA_CODE_BORDER_SIZE)), GUILayout.Height(WARNING_ICON_SIZE), GUILayout.ExpandHeight(true));
+            GUILayout.FlexibleSpace();
+            GUILayout.Space(ENTER_2FA_CODE_BORDER_SIZE);
+            EditorGUILayout.EndHorizontal();
+        }
+
+        EditorGUILayout.BeginHorizontal();
+        GUILayout.Space(ENTER_2FA_CODE_BORDER_SIZE);
+        GUILayout.FlexibleSpace();
+        Vector2 size = EditorStyles.boldLabel.CalcSize(new GUIContent(ENTER_2FA_CODE_LABEL_STRING));
+        EditorGUILayout.LabelField(ENTER_2FA_CODE_LABEL_STRING, EditorStyles.boldLabel, GUILayout.MaxWidth(size.x));
+        authenticationCode = EditorGUILayout.TextField(authenticationCode);
+
+        // Verify 2FA code button
+        if (GUILayout.Button(ENTER_2FA_CODE_VERIFY_STRING, GUILayout.Width(ENTER_2FA_CODE_VERIFY_BUTTON_WIDTH)))
+        {
+            checkingCode = true;
+            APIUser.VerifyTwoFactorAuthCode(authenticationCode, isValidAuthenticationCode ? API2FA.TIME_BASED_ONE_TIME_PASSWORD_AUTHENTICATION : API2FA.ONE_TIME_PASSWORD_AUTHENTICATION, username, password,
+                    delegate
+                    {
+                        // valid 2FA code submitted
+                        entered2faCodeIsInvalid = false;
+                        authorizationCodeWasVerified = true;
+                        checkingCode = false;
+                        showTwoFactorAuthenticationEntry = false;
+                        if (null != onAuthenticationVerifiedAction)
+                            onAuthenticationVerifiedAction();
+                    },
+                    delegate
+                    {
+                        entered2faCodeIsInvalid = true;
+                        checkingCode = false;
+                    }
+                );
+        }
+
+        GUILayout.FlexibleSpace();
+        GUILayout.Space(ENTER_2FA_CODE_BORDER_SIZE);
+        EditorGUILayout.EndHorizontal();
+
+        GUILayout.FlexibleSpace();
+
+        EditorGUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+
+        // after user has entered an invalid code causing the invalid code message to be displayed,
+        // edit the code will change it's length meaning it is invalid format, so we can clear the invalid code setting until they resubmit
+        if (previousAuthenticationCodeLength != authenticationCode.Length)
+        {
+            previousAuthenticationCodeLength = authenticationCode.Length;
+            entered2faCodeIsInvalid = false;
+        }
+
+        GUI.enabled = true;
+        GUILayout.FlexibleSpace();
+        GUILayout.Space(ENTER_2FA_CODE_BORDER_SIZE);
+        EditorGUILayout.EndHorizontal();
+
+        GUILayout.FlexibleSpace();
+
+        // Two-Factor Authentication Help button
+        EditorGUILayout.BeginHorizontal();
+        if (GUILayout.Button(ENTER_2FA_CODE_HELP_STRING))
+        {
+            Application.OpenURL(TWO_FACTOR_AUTHENTICATION_HELP_URL);
+        }
+        EditorGUILayout.EndHorizontal();
+
+        // Cancel button
+        EditorGUILayout.BeginHorizontal();
+        if (GUILayout.Button(ENTER_2FA_CODE_CANCEL_STRING))
+        {
+            showTwoFactorAuthenticationEntry = false;
+            Logout();
+        }
+        EditorGUILayout.EndHorizontal();
+    }
+
+    private static string Status
+    {
+        get
+        {
+            if (!APIUser.IsLoggedInWithCredentials)
+                return error == null ? "Please log in." : "Error in authenticating: " + error;
+            if (signingIn)
+                return "Logging in.";
+            else
+            {
+                if( serverEnvironment == ApiServerEnvironment.Dev )
+                    return "Connected to " + serverEnvironment.ToString();
+                return "Connected";
+            }
+        }
+    }
+
+    private static void OnAuthenticationCompleted()
+    {
+        AttemptLogin();
+    }
+
+    private static void AttemptLogin()
+    {
+        APIUser.Login(username, password,
+            delegate (ApiModelContainer<APIUser> c)
+            {
+                APIUser user = c.Model as APIUser;
+                if (c.Cookies.ContainsKey("auth"))
+                    ApiCredentials.Set(user.username, username, "vrchat", c.Cookies["auth"]);
+                else
+                    ApiCredentials.SetHumanName(user.username);
+                signingIn = false;
+                error = null;
+                storedUsername = username;
+                storedPassword = password;
+                AnalyticsSDK.LoggedInUserChanged(user);
+
+                if (!APIUser.CurrentUser.canPublishAllContent)
+                {
+                    if (UnityEditor.SessionState.GetString("HasShownContentPublishPermissionsDialogForUser", "") != user.id)
+                    {
+                        UnityEditor.SessionState.SetString("HasShownContentPublishPermissionsDialogForUser", user.id);
+                        VRCSdkControlPanel.ShowContentPublishPermissionsDialog();
+                    }
+                }
+            },
+            delegate (ApiModelContainer<APIUser> c)
+            {
+                Logout();
+                error = c.Error;
+                VRC.Core.Logger.Log("Error logging in: " + error);
+            },
+            delegate (ApiModelContainer<API2FA> c)
+            {
+                if (c.Cookies.ContainsKey("auth"))
+                    ApiCredentials.Set(username, username, "vrchat", c.Cookies["auth"]);
+                showTwoFactorAuthenticationEntry = true;
+                onAuthenticationVerifiedAction = OnAuthenticationCompleted;
+            }
+        );
+    }
+
+
+    private static object syncObject = new object();
+    private static void SignIn(bool explicitAttempt)
+    {
+        lock (syncObject)
+        {
+            if (signingIn
+                || APIUser.IsLoggedInWithCredentials
+                || (!explicitAttempt && string.IsNullOrEmpty(storedUsername))
+                || (!explicitAttempt && string.IsNullOrEmpty(storedPassword)))
+                return;
+
+            signingIn = true;
+        }
+
+        InitAccount();
+
+        AttemptLogin();
+    }
+
+    public static void Logout()
+    {
+        signingIn = false;
+        storedUsername = null;
+        storedPassword = null;
+        VRC.Tools.ClearCookies();
+        APIUser.Logout();
+    }
+
+    private void AccountDestroy()
+    {
+        signingIn = false;
+        isInitialized = false;
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelAccount.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5066cd5c1cc208143a1253cac821714a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelBuilder.cs

@@ -0,0 +1,639 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using VRCSDK2.Validation.Performance;
+using Object = UnityEngine.Object;
+using VRC.SDK3.Editor;
+using VRC.SDKBase.Editor;
+
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    public static System.Action _EnableSpatialization = null;   // assigned in AutoAddONSPAudioSourceComponents
+
+    public const string AVATAR_OPTIMIZATION_TIPS_URL = "https://docs.vrchat.com/docs/avatar-optimizing-tips";
+    public const string AVATAR_RIG_REQUIREMENTS_URL = "https://docs.vrchat.com/docs/rig-requirements";
+
+    const string kCantPublishContent = "Before you can upload avatars or worlds, you will need to spend some time in VRChat.";
+    const string kCantPublishAvatars = "Before you can upload avatars, you will need to spend some time in VRChat.";
+    const string kCantPublishWorlds = "Before you can upload worlds, you will need to spend some time in VRChat.";
+    private const string FIX_ISSUES_TO_BUILD_OR_TEST_WARNING_STRING = "You must address the above issues before you can build or test this content!";
+    
+    static Texture _perfIcon_Excellent;
+    static Texture _perfIcon_Good;
+    static Texture _perfIcon_Medium;
+    static Texture _perfIcon_Poor;
+    static Texture _perfIcon_VeryPoor;
+    static Texture _bannerImage;
+
+    public void ResetIssues()
+    {
+        GUIErrors.Clear();
+        GUIInfos.Clear();
+        GUIWarnings.Clear();
+        GUILinks.Clear();
+        GUIStats.Clear();
+        CheckedForIssues = false;
+    }
+
+    public bool CheckedForIssues { get; set; } = false;
+
+    class Issue
+    {
+        public string issueText;
+        public System.Action showThisIssue;
+        public System.Action fixThisIssue;
+        public PerformanceRating performanceRating;
+
+        public Issue(string text, System.Action show, System.Action fix, PerformanceRating rating = PerformanceRating.None)
+        {
+            issueText = text;
+            showThisIssue = show;
+            fixThisIssue = fix;
+            performanceRating = rating;
+        }
+
+        public class Equality : IEqualityComparer<Issue>, IComparer<Issue>
+        {
+            public bool Equals(Issue b1, Issue b2)
+            {
+                return (b1.issueText == b2.issueText);
+            }
+            public int Compare(Issue b1, Issue b2)
+            {
+                return string.Compare(b1.issueText, b2.issueText);
+            }
+            public int GetHashCode(Issue bx)
+            {
+                return bx.issueText.GetHashCode();
+            }
+        }
+    }
+
+    Dictionary<Object, List<Issue>> GUIErrors = new Dictionary<Object, List<Issue>>();
+    Dictionary<Object, List<Issue>> GUIWarnings = new Dictionary<Object, List<Issue>>();
+    Dictionary<Object, List<Issue>> GUIInfos = new Dictionary<Object, List<Issue>>();
+    Dictionary<Object, List<Issue>> GUILinks = new Dictionary<Object, List<Issue>>();
+    Dictionary<Object, List<Issue>> GUIStats = new Dictionary<Object, List<Issue>>();
+
+    public bool NoGuiErrorsOrIssues()
+    {
+        return GUIErrors.Count == 0 && CheckedForIssues;
+    }
+    
+    void AddToReport(Dictionary<Object, List<Issue>> report, Object subject, string output, System.Action show, System.Action fix)
+    {
+        if (subject == null)
+            subject = this;
+        if (!report.ContainsKey(subject))
+            report.Add(subject, new List<Issue>());
+
+        var issue = new Issue(output, show, fix);
+        if (!report[subject].Contains(issue, new Issue.Equality()))
+        {
+            report[subject].Add(issue);
+            report[subject].Sort(new Issue.Equality());
+        }
+    }
+
+    void BuilderAssemblyReload()
+    {
+        ResetIssues();
+    }
+
+    public void OnGUIError(Object subject, string output, System.Action show, System.Action fix)
+    {
+        AddToReport(GUIErrors, subject, output, show, fix);
+    }
+
+    public void OnGUIWarning(Object subject, string output, System.Action show, System.Action fix)
+    {
+        AddToReport(GUIWarnings, subject, output, show, fix);
+    }
+
+    public void OnGUIInformation(Object subject, string output)
+    {
+        AddToReport(GUIInfos, subject, output, null, null);
+    }
+
+    public void OnGUILink(Object subject, string output, string link)
+    {
+        AddToReport(GUILinks, subject, output + "\n" + link, null, null);
+    }
+
+    public void OnGUIStat(Object subject, string output, PerformanceRating rating, System.Action show, System.Action fix)
+    {
+        if (subject == null)
+            subject = this;
+        if (!GUIStats.ContainsKey(subject))
+            GUIStats.Add(subject, new List<Issue>());
+        GUIStats[subject].Add(new Issue(output, show, fix, rating));
+    }
+
+    public int triggerLineMode
+    {
+        get { return EditorPrefs.GetInt("VRC.SDKBase_triggerLineMode", 0); }
+        set { EditorPrefs.SetInt("VRC.SDKBase_triggerLineMode", value); }
+    }
+
+    private void ShowSettingsOptionsForBuilders()
+    {
+        if (_sdkBuilders == null)
+        {
+            PopulateSdkBuilders();
+        }
+        for (int i = 0; i < _sdkBuilders.Length; i++)
+        {
+            IVRCSdkControlPanelBuilder builder = _sdkBuilders[i];
+            builder.ShowSettingsOptions();
+            if (i < _sdkBuilders.Length - 1)
+            {
+                EditorGUILayout.Separator();
+            }
+        }
+    }
+    
+    private IVRCSdkControlPanelBuilder[] _sdkBuilders;
+    
+    private static List<Type> GetSdkBuilderTypesFromAttribute()
+    {
+        Type sdkBuilderInterfaceType = typeof(IVRCSdkControlPanelBuilder);
+        Type sdkBuilderAttributeType = typeof(VRCSdkControlPanelBuilderAttribute);
+
+        List<Type> moduleTypesFromAttribute = new List<Type>();
+        foreach(Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            VRCSdkControlPanelBuilderAttribute[] sdkBuilderAttributes;
+            try
+            {
+                sdkBuilderAttributes = (VRCSdkControlPanelBuilderAttribute[])assembly.GetCustomAttributes(sdkBuilderAttributeType, false);
+            }
+            catch
+            {
+                sdkBuilderAttributes = new VRCSdkControlPanelBuilderAttribute[0];
+            }
+
+            foreach(VRCSdkControlPanelBuilderAttribute udonWrapperModuleAttribute in sdkBuilderAttributes)
+            {
+                if(udonWrapperModuleAttribute == null)
+                {
+                    continue;
+                }
+
+                if(!sdkBuilderInterfaceType.IsAssignableFrom(udonWrapperModuleAttribute.Type))
+                {
+                    continue;
+                }
+
+                moduleTypesFromAttribute.Add(udonWrapperModuleAttribute.Type);
+            }
+        }
+
+        return moduleTypesFromAttribute;
+    }
+
+    private void PopulateSdkBuilders()
+    {
+        if (_sdkBuilders != null)
+        {
+            return;
+        }
+        List<IVRCSdkControlPanelBuilder> builders = new List<IVRCSdkControlPanelBuilder>();
+        foreach (Type type in GetSdkBuilderTypesFromAttribute())
+        {
+            IVRCSdkControlPanelBuilder builder = (IVRCSdkControlPanelBuilder)Activator.CreateInstance(type);
+            builder.RegisterBuilder(this);
+            builders.Add(builder);
+        }
+        _sdkBuilders = builders.ToArray();
+    }
+    
+    void ShowBuilders()
+    {
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.BeginVertical();
+        
+        if (VRC.Core.ConfigManager.RemoteConfig.IsInitialized())
+        {
+            string sdkUnityVersion = VRC.Core.ConfigManager.RemoteConfig.GetString("sdkUnityVersion");
+            if (Application.unityVersion != sdkUnityVersion)
+            {
+                OnGUIWarning(null, "You are not using the recommended Unity version for the VRChat SDK. Content built with this version may not work correctly. Please use Unity " + sdkUnityVersion,
+                    null,
+                    () => { Application.OpenURL("https://unity3d.com/get-unity/download/archive"); }
+                );
+            }
+        }
+        
+        if (VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK2) && VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK3))
+        {
+            List<Component> sdk2Components = VRCSdk3Analysis.GetSDKInScene(VRCSdk3Analysis.SdkVersion.VRCSDK2);
+            List<Component> sdk3Components = VRCSdk3Analysis.GetSDKInScene(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+            if (sdk2Components.Count > 0 && sdk3Components.Count > 0)
+            {
+                OnGUIError(null,
+                    "This scene contains components from the VRChat SDK version 2 and version 3. Version two elements will have to be replaced with their version 3 counterparts to build with SDK3 and UDON.",
+                    () => { Selection.objects = sdk2Components.ToArray(); },
+                    null
+                );
+            }
+        }
+        
+        if (Lightmapping.giWorkflowMode == Lightmapping.GIWorkflowMode.Iterative)
+        {
+            OnGUIWarning(null,
+                "Automatic lightmap generation is enabled, which may stall the Unity build process. Before building and uploading, consider turning off 'Auto Generate' at the bottom of the Lighting Window.",
+                () =>
+                {
+                    EditorWindow lightingWindow = GetLightingWindow();
+                    if (lightingWindow)
+                    {
+                        lightingWindow.Show();
+                        lightingWindow.Focus();
+                    }
+                },
+                () =>
+                {
+                    Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.OnDemand;
+                    EditorWindow lightingWindow = GetLightingWindow();
+                    if (!lightingWindow) return;
+                    lightingWindow.Repaint();
+                    Focus();
+                }
+            );
+        }
+        
+        PopulateSdkBuilders();
+        IVRCSdkControlPanelBuilder selectedBuilder = null;
+        string errorMessage = null;
+        foreach (IVRCSdkControlPanelBuilder sdkBuilder in _sdkBuilders)
+        {
+            if (!sdkBuilder.IsValidBuilder(out string message))
+            {
+                if (selectedBuilder == null)
+                {
+                    errorMessage = message;
+                }
+            }
+            else
+            {
+                if (selectedBuilder == null)
+                {
+                    selectedBuilder = sdkBuilder;
+                    errorMessage = null;
+                }
+                else
+                {
+                    errorMessage =
+                        "A Unity scene cannot contain a VRChat Scene Descriptor and also contain VRChat Avatar Descriptors";
+                }
+            }
+        }
+        if (selectedBuilder == null)
+        {
+#if VRC_SDK_VRCSDK2
+            EditorGUILayout.LabelField("A VRC_SceneDescriptor or VRC_AvatarDescriptor\nis required to build VRChat SDK Content", titleGuiStyle, GUILayout.Width(SdkWindowWidth));
+#elif VRC_SDK_VRCSDK3
+            EditorGUILayout.LabelField("A VRCSceneDescriptor or VRCAvatarDescriptor\nis required to build VRChat SDK Content", titleGuiStyle, GUILayout.Width(SdkWindowWidth));
+#endif
+        }
+        else if (errorMessage != null)
+        {
+            OnGUIError(null,
+                errorMessage,
+                () => {
+                    foreach (IVRCSdkControlPanelBuilder builder in _sdkBuilders)
+                    {
+                        builder.SelectAllComponents();
+                    } },
+                null
+            );    
+            OnGUIShowIssues();
+        }
+        else
+        {
+            selectedBuilder.ShowBuilder();
+        }
+
+        if (Event.current.type == EventType.Used) return;
+        GUILayout.EndVertical();
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+    }
+
+    public bool showLayerHelp = false;
+    
+    bool ShouldShowLightmapWarning
+    {
+        get
+        {
+            const string GraphicsSettingsAssetPath = "ProjectSettings/GraphicsSettings.asset";
+            SerializedObject graphicsManager = new SerializedObject(UnityEditor.AssetDatabase.LoadAllAssetsAtPath(GraphicsSettingsAssetPath)[0]);
+            SerializedProperty lightmapStripping = graphicsManager.FindProperty("m_LightmapStripping");
+            return lightmapStripping.enumValueIndex == 0;
+        }
+    }
+
+    bool ShouldShowFogWarning
+    {
+        get
+        {
+            const string GraphicsSettingsAssetPath = "ProjectSettings/GraphicsSettings.asset";
+            SerializedObject graphicsManager = new SerializedObject(UnityEditor.AssetDatabase.LoadAllAssetsAtPath(GraphicsSettingsAssetPath)[0]);
+            SerializedProperty lightmapStripping = graphicsManager.FindProperty("m_FogStripping");
+            return lightmapStripping.enumValueIndex == 0;
+        }
+    }
+
+    void DrawIssueBox(MessageType msgType, Texture icon, string message, System.Action show, System.Action fix)
+    {
+        bool haveButtons = ((show != null) || (fix != null));
+
+        GUIStyle style = new GUIStyle("HelpBox");
+        style.fixedWidth = (haveButtons ? (SdkWindowWidth - 90) : SdkWindowWidth);
+        float minHeight = 40;
+
+        try
+        {
+            EditorGUILayout.BeginHorizontal();
+            if (icon != null)
+            {
+                GUIContent c = new GUIContent(message, icon);
+                float height = style.CalcHeight(c, style.fixedWidth);
+                GUILayout.Box(c, style, GUILayout.MinHeight(Mathf.Max(minHeight, height)));
+            }
+            else
+            {
+                GUIContent c = new GUIContent(message);
+                float height = style.CalcHeight(c, style.fixedWidth);
+                Rect rt = GUILayoutUtility.GetRect(c, style, GUILayout.MinHeight(Mathf.Max(minHeight, height)));
+                EditorGUI.HelpBox(rt, message, msgType);    // note: EditorGUILayout resulted in uneven button layout in this case
+            }
+
+            if (haveButtons)
+            {
+                EditorGUILayout.BeginVertical();
+                float buttonHeight = ((show == null || fix == null) ? minHeight : (minHeight * 0.5f));
+                if ((show != null) && GUILayout.Button("Select", GUILayout.Height(buttonHeight)))
+                    show();
+                if ((fix != null) && GUILayout.Button("Auto Fix", GUILayout.Height(buttonHeight)))
+                {
+                    fix();
+                    EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+                    CheckedForIssues = false;
+                    Repaint();
+                }
+                EditorGUILayout.EndVertical();
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+        catch
+        {
+            // mutes 'ArgumentException: Getting control 0's position in a group with only 0 controls when doing repaint'
+        }
+    }
+
+    public void OnGuiFixIssuesToBuildOrTest()
+    {
+        GUIStyle s = new GUIStyle(EditorStyles.label) { alignment = TextAnchor.MiddleCenter };
+        EditorGUILayout.Space();
+        GUILayout.BeginVertical(boxGuiStyle, GUILayout.Height(WARNING_ICON_SIZE), GUILayout.Width(SdkWindowWidth));
+        GUILayout.FlexibleSpace();
+        EditorGUILayout.BeginHorizontal();
+        var textDimensions = s.CalcSize(new GUIContent(FIX_ISSUES_TO_BUILD_OR_TEST_WARNING_STRING));
+        GUILayout.Label(new GUIContent(warningIconGraphic), GUILayout.Width(WARNING_ICON_SIZE), GUILayout.Height(WARNING_ICON_SIZE));
+        EditorGUILayout.LabelField(FIX_ISSUES_TO_BUILD_OR_TEST_WARNING_STRING, s, GUILayout.Width(textDimensions.x), GUILayout.Height(WARNING_ICON_SIZE));
+        EditorGUILayout.EndHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.EndVertical();
+    }
+
+    public void OnGUIShowIssues(Object subject = null)
+    {
+        if (subject == null)
+            subject = this;
+
+        EditorGUI.BeginChangeCheck();
+
+        GUIStyle style = GUI.skin.GetStyle("HelpBox");
+
+        if (GUIErrors.ContainsKey(subject))
+            foreach (Issue error in GUIErrors[subject].Where(s => !string.IsNullOrEmpty(s.issueText)))
+                DrawIssueBox(MessageType.Error, null, error.issueText, error.showThisIssue, error.fixThisIssue);
+        if (GUIWarnings.ContainsKey(subject))
+            foreach (Issue error in GUIWarnings[subject].Where(s => !string.IsNullOrEmpty(s.issueText)))
+                DrawIssueBox(MessageType.Warning, null, error.issueText, error.showThisIssue, error.fixThisIssue);
+
+        if (GUIStats.ContainsKey(subject))
+        {
+            foreach (var kvp in GUIStats[subject].Where(k => k.performanceRating == PerformanceRating.VeryPoor))
+                DrawIssueBox(MessageType.Warning, GetPerformanceIconForRating(kvp.performanceRating), kvp.issueText, kvp.showThisIssue, kvp.fixThisIssue);
+
+            foreach (var kvp in GUIStats[subject].Where(k => k.performanceRating == PerformanceRating.Poor))
+                DrawIssueBox(MessageType.Warning, GetPerformanceIconForRating(kvp.performanceRating), kvp.issueText, kvp.showThisIssue, kvp.fixThisIssue);
+
+            foreach (var kvp in GUIStats[subject].Where(k => k.performanceRating == PerformanceRating.Medium))
+                DrawIssueBox(MessageType.Warning, GetPerformanceIconForRating(kvp.performanceRating), kvp.issueText, kvp.showThisIssue, kvp.fixThisIssue);
+
+            foreach (var kvp in GUIStats[subject].Where(k => k.performanceRating == PerformanceRating.Good || k.performanceRating == PerformanceRating.Excellent))
+                DrawIssueBox(MessageType.Warning, GetPerformanceIconForRating(kvp.performanceRating), kvp.issueText, kvp.showThisIssue, kvp.fixThisIssue);
+        }
+
+        if (GUIInfos.ContainsKey(subject))
+            foreach (Issue error in GUIInfos[subject].Where(s => !string.IsNullOrEmpty(s.issueText)))
+                EditorGUILayout.HelpBox(error.issueText, MessageType.Info);
+        if (GUILinks.ContainsKey(subject))
+        {
+            EditorGUILayout.BeginVertical(style);
+            foreach (Issue error in GUILinks[subject].Where(s => !string.IsNullOrEmpty(s.issueText)))
+            {
+                var s = error.issueText.Split('\n');
+                EditorGUILayout.BeginHorizontal();
+                GUILayout.Label(s[0]);
+                if (GUILayout.Button("Open Link", GUILayout.Width(100)))
+                    Application.OpenURL(s[1]);
+                EditorGUILayout.EndHorizontal();
+            }
+            EditorGUILayout.EndVertical();
+        }
+
+        if (EditorGUI.EndChangeCheck())
+        {
+            EditorUtility.SetDirty(subject);
+            UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());
+        }
+    }
+
+    private Texture GetPerformanceIconForRating(PerformanceRating value)
+    {
+        if (_perfIcon_Excellent == null)
+            _perfIcon_Excellent = Resources.Load<Texture>("PerformanceIcons/Perf_Great_32");
+        if (_perfIcon_Good == null)
+            _perfIcon_Good = Resources.Load<Texture>("PerformanceIcons/Perf_Good_32");
+        if (_perfIcon_Medium == null)
+            _perfIcon_Medium = Resources.Load<Texture>("PerformanceIcons/Perf_Medium_32");
+        if (_perfIcon_Poor == null)
+            _perfIcon_Poor = Resources.Load<Texture>("PerformanceIcons/Perf_Poor_32");
+        if (_perfIcon_VeryPoor == null)
+            _perfIcon_VeryPoor = Resources.Load<Texture>("PerformanceIcons/Perf_Horrible_32");
+
+        switch (value)
+        {
+            case PerformanceRating.Excellent:
+                return _perfIcon_Excellent;
+            case PerformanceRating.Good:
+                return _perfIcon_Good;
+            case PerformanceRating.Medium:
+                return _perfIcon_Medium;
+            case PerformanceRating.Poor:
+                return _perfIcon_Poor;
+            case PerformanceRating.None:
+            case PerformanceRating.VeryPoor:
+                return _perfIcon_VeryPoor;
+        }
+
+        return _perfIcon_Excellent;
+    }
+
+    Texture2D CreateBackgroundColorImage(UnityEngine.Color color)
+    {
+        int w = 4, h = 4;
+        Texture2D back = new Texture2D(w, h);
+        UnityEngine.Color[] buffer = new UnityEngine.Color[w * h];
+        for (int i = 0; i < w; ++i)
+            for (int j = 0; j < h; ++j)
+                buffer[i + w * j] = color;
+        back.SetPixels(buffer);
+        back.Apply(false);
+        return back;
+    }
+
+    public static void DrawContentInfo(string name, string version, string description, string capacity, string releaseStatus, List<string> tags)
+    {
+        EditorGUILayout.LabelField("Name: " + name);
+        EditorGUILayout.LabelField("Version: " + version.ToString());
+        EditorGUILayout.LabelField("Description: " + description);
+        if (capacity != null)
+            EditorGUILayout.LabelField("Capacity: " + capacity);
+        EditorGUILayout.LabelField("Release: " + releaseStatus);
+        if (tags != null)
+        {
+            string tagString = "";
+            for (int i = 0; i < tags.Count; i++)
+            {
+                if (i != 0) tagString += ", ";
+                tagString += tags[i];
+            }
+            EditorGUILayout.LabelField("Tags: " + tagString);
+
+        }
+    }
+    public static void DrawContentPlatformSupport(VRC.Core.ApiModel m)
+    {
+        if (m.supportedPlatforms == VRC.Core.ApiModel.SupportedPlatforms.StandaloneWindows || m.supportedPlatforms == VRC.Core.ApiModel.SupportedPlatforms.All)
+            EditorGUILayout.LabelField("Windows Support: YES");
+        else
+            EditorGUILayout.LabelField("Windows Support: NO");
+
+        if (m.supportedPlatforms == VRC.Core.ApiModel.SupportedPlatforms.Android || m.supportedPlatforms == VRC.Core.ApiModel.SupportedPlatforms.All)
+            EditorGUILayout.LabelField("Android Support: YES");
+        else
+            EditorGUILayout.LabelField("Android Support: NO");
+    }
+
+    public static void DrawBuildTargetSwitcher()
+    {
+        EditorGUILayout.LabelField("Active Build Target: " + EditorUserBuildSettings.activeBuildTarget);
+        if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows || EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows64 && GUILayout.Button("Switch Build Target to Android"))
+        {
+            if (EditorUtility.DisplayDialog("Build Target Switcher", "Are you sure you want to switch your build target to Android? This could take a while.", "Confirm", "Cancel"))
+                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.Android, BuildTarget.Android);
+        }
+        if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android && GUILayout.Button("Switch Build Target to Windows"))
+        {
+            if (EditorUtility.DisplayDialog("Build Target Switcher", "Are you sure you want to switch your build target to Windows? This could take a while.", "Confirm", "Cancel"))
+                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.Standalone, BuildTarget.StandaloneWindows64);
+        }
+    }
+
+    public static string GetBuildAndPublishButtonString()
+    {
+        string buildButtonString = "Build & Publish for UNSUPPORTED";
+        if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows || EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows64)
+            buildButtonString = "Build & Publish for Windows";
+        if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
+            buildButtonString = "Build & Publish for Android";
+
+        return buildButtonString;
+    }
+
+    public static Object[] GetSubstanceObjects(GameObject obj = null, bool earlyOut = false)
+    {
+        // if 'obj' is null we check entire scene
+        // if 'earlyOut' is true we only return 1st object (to detect if substances are present)
+
+        List<Object> objects = new List<Object>();
+        if (obj == null) return objects.Count < 1 ? null : objects.ToArray();
+        Renderer[] renderers = obj ? obj.GetComponentsInChildren<Renderer>(true) : FindObjectsOfType<Renderer>();
+
+        if (renderers == null || renderers.Length < 1)
+            return null;
+        foreach (Renderer r in renderers)
+        {
+            if (r.sharedMaterials.Length < 1)
+                continue;
+            foreach (Material m in r.sharedMaterials)
+            {
+                if (!m)
+                    continue;
+                string path = AssetDatabase.GetAssetPath(m);
+                if (string.IsNullOrEmpty(path))
+                    continue;
+                if (path.EndsWith(".sbsar", true, System.Globalization.CultureInfo.InvariantCulture))
+                {
+                    objects.Add(r.gameObject);
+                    if (earlyOut)
+                        return objects.ToArray();
+                }
+            }
+        }
+
+        return objects.Count < 1 ? null : objects.ToArray();
+    }
+
+    public static bool HasSubstances(GameObject obj = null)
+    {
+        return (GetSubstanceObjects(obj, true) != null);
+    }
+
+    EditorWindow GetLightingWindow()
+    {
+        var editorAsm = typeof(UnityEditor.Editor).Assembly;
+        return EditorWindow.GetWindow(editorAsm.GetType("UnityEditor.LightingWindow"));
+    }
+
+    public static void ShowContentPublishPermissionsDialog()
+    {
+        if (!VRC.Core.ConfigManager.RemoteConfig.IsInitialized())
+        {
+            VRC.Core.ConfigManager.RemoteConfig.Init(() => ShowContentPublishPermissionsDialog());
+            return;
+        }
+
+        string message = VRC.Core.ConfigManager.RemoteConfig.GetString("sdkNotAllowedToPublishMessage");
+        int result = UnityEditor.EditorUtility.DisplayDialogComplex("VRChat SDK", message, "Developer FAQ", "VRChat Discord", "OK");
+        if (result == 0)
+        {
+            ShowDeveloperFAQ();
+        }
+        if (result == 1)
+        {
+            ShowVRChatDiscord();
+        }
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelBuilder.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4c73e735ee0380241b186a8993fa56bf
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelBuilderAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using UnityEngine;
+
+namespace VRC.SDKBase.Editor
+{
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+    [MeansImplicitUse]
+    public class VRCSdkControlPanelBuilderAttribute : Attribute
+    {
+        public Type Type { get; }
+        public VRCSdkControlPanelBuilderAttribute(Type type)
+        {
+            Type = type;
+        }
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelBuilderAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c768b42ca9a2f2b48afeb1fa03d5e1bf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelContent.cs

@@ -0,0 +1,682 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Networking;
+using VRC.Core;
+
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    const int PageLimit = 20;
+
+    static List<ApiAvatar> uploadedAvatars = null;
+    static List<ApiWorld> uploadedWorlds = null;
+    static List<ApiAvatar> testAvatars = null;
+
+    public static Dictionary<string, Texture2D> ImageCache = new Dictionary<string, Texture2D>();
+
+    static List<string> justDeletedContents;
+    static List<ApiAvatar> justUpdatedAvatars;
+
+    static EditorCoroutine fetchingAvatars = null, fetchingWorlds = null;
+
+    private static string searchString = "";
+    private static bool WorldsToggle = true;
+    private static bool AvatarsToggle = true;
+    private static bool TestAvatarsToggle = true;
+
+    const int SCROLLBAR_RESERVED_REGION_WIDTH = 50;
+
+    const int WORLD_DESCRIPTION_FIELD_WIDTH = 140;
+    const int WORLD_IMAGE_BUTTON_WIDTH = 100;
+    const int WORLD_IMAGE_BUTTON_HEIGHT = 100;
+    const int WORLD_RELEASE_STATUS_FIELD_WIDTH = 150;
+    const int COPY_WORLD_ID_BUTTON_WIDTH = 75;
+    const int DELETE_WORLD_BUTTON_WIDTH = 75;
+    const int WORLD_ALL_INFORMATION_MAX_WIDTH = WORLD_DESCRIPTION_FIELD_WIDTH + WORLD_IMAGE_BUTTON_WIDTH + WORLD_RELEASE_STATUS_FIELD_WIDTH + COPY_WORLD_ID_BUTTON_WIDTH + DELETE_WORLD_BUTTON_WIDTH + SCROLLBAR_RESERVED_REGION_WIDTH;
+    const int WORLD_REDUCED_INFORMATION_MAX_WIDTH = WORLD_DESCRIPTION_FIELD_WIDTH + WORLD_IMAGE_BUTTON_WIDTH + WORLD_RELEASE_STATUS_FIELD_WIDTH + SCROLLBAR_RESERVED_REGION_WIDTH;
+
+    const int AVATAR_DESCRIPTION_FIELD_WIDTH = 140;
+    const int AVATAR_IMAGE_BUTTON_WIDTH = WORLD_IMAGE_BUTTON_WIDTH;
+    const int AVATAR_IMAGE_BUTTON_HEIGHT = WORLD_IMAGE_BUTTON_HEIGHT;
+    const int AVATAR_RELEASE_STATUS_FIELD_WIDTH = 150;
+    const int SET_AVATAR_STATUS_BUTTON_WIDTH = 100;
+    const int COPY_AVATAR_ID_BUTTON_WIDTH = COPY_WORLD_ID_BUTTON_WIDTH;
+    const int DELETE_AVATAR_BUTTON_WIDTH = DELETE_WORLD_BUTTON_WIDTH;
+    const int AVATAR_ALL_INFORMATION_MAX_WIDTH = AVATAR_DESCRIPTION_FIELD_WIDTH + AVATAR_IMAGE_BUTTON_WIDTH + AVATAR_RELEASE_STATUS_FIELD_WIDTH + SET_AVATAR_STATUS_BUTTON_WIDTH + COPY_AVATAR_ID_BUTTON_WIDTH + DELETE_AVATAR_BUTTON_WIDTH + SCROLLBAR_RESERVED_REGION_WIDTH;
+    const int AVATAR_REDUCED_INFORMATION_MAX_WIDTH = AVATAR_DESCRIPTION_FIELD_WIDTH + AVATAR_IMAGE_BUTTON_WIDTH + AVATAR_RELEASE_STATUS_FIELD_WIDTH + SCROLLBAR_RESERVED_REGION_WIDTH;
+
+    const int MAX_ALL_INFORMATION_WIDTH = WORLD_ALL_INFORMATION_MAX_WIDTH > AVATAR_ALL_INFORMATION_MAX_WIDTH ? WORLD_ALL_INFORMATION_MAX_WIDTH : AVATAR_ALL_INFORMATION_MAX_WIDTH;
+    const int MAX_REDUCED_INFORMATION_WIDTH = WORLD_REDUCED_INFORMATION_MAX_WIDTH > AVATAR_REDUCED_INFORMATION_MAX_WIDTH ? WORLD_REDUCED_INFORMATION_MAX_WIDTH : AVATAR_REDUCED_INFORMATION_MAX_WIDTH;
+
+    public static void ClearContent()
+    {
+        if (uploadedWorlds != null)
+            uploadedWorlds = null;
+        if (uploadedAvatars != null)
+            uploadedAvatars = null;
+        if (testAvatars != null)
+            testAvatars = null;
+        ImageCache.Clear();
+    }
+
+    IEnumerator FetchUploadedData()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+            ConfigManager.RemoteConfig.Init();
+
+        if (!APIUser.IsLoggedInWithCredentials)
+            yield break;
+
+        ApiCache.ClearResponseCache();
+        VRCCachedWWW.ClearOld();
+
+        if (fetchingAvatars == null)
+            fetchingAvatars = EditorCoroutine.Start(() => FetchAvatars());
+        if (fetchingWorlds == null)
+            fetchingWorlds = EditorCoroutine.Start(() => FetchWorlds());
+        FetchTestAvatars();
+    }
+
+    private static void FetchAvatars(int offset = 0)
+    {
+        ApiAvatar.FetchList(
+            delegate (IEnumerable<ApiAvatar> obj)
+            {
+                if (obj.FirstOrDefault() != null)
+                    fetchingAvatars = EditorCoroutine.Start(() =>
+                    {
+                        var l = obj.ToList();
+                        int count = l.Count;
+                        SetupAvatarData(l);
+                        FetchAvatars(offset + count);
+                    });
+                else
+                {
+                    fetchingAvatars = null;
+                    foreach (ApiAvatar a in uploadedAvatars)
+                        DownloadImage(a.id, a.thumbnailImageUrl);
+                }
+            },
+            delegate (string obj)
+            {
+                Debug.LogError("Error fetching your uploaded avatars:\n" + obj);
+                fetchingAvatars = null;
+            },
+            ApiAvatar.Owner.Mine,
+            ApiAvatar.ReleaseStatus.All,
+            null,
+            PageLimit,
+            offset,
+            ApiAvatar.SortHeading.None,
+            ApiAvatar.SortOrder.Descending,
+            null,
+            null, 
+            true,
+            false,
+            null,
+            false
+            );
+    }
+
+    private static void FetchTestAvatars()
+    {
+#if VRC_SDK_VRCSDK3
+        string sdkAvatarFolder = VRC.SDK3.Editor.VRC_SdkBuilder.GetKnownFolderPath(VRC.SDK3.Editor.VRC_SdkBuilder.LocalLowGUID) + "/VRChat/vrchat/Avatars/";
+        string[] sdkavatars = Directory.GetFiles(sdkAvatarFolder);
+        string filename = "";
+        List<ApiAvatar> avatars = new List<ApiAvatar>();
+        foreach(string sdkap in sdkavatars)
+        {
+            if(Path.GetExtension(sdkap) != ".vrca")
+                continue;
+
+            filename = Path.GetFileNameWithoutExtension(sdkap);
+            ApiAvatar sdka = API.FromCacheOrNew<ApiAvatar>("local:sdk_" + filename);
+            sdka.assetUrl = sdkap;
+            sdka.name = filename;
+            sdka.releaseStatus = "public";
+            ApiAvatar.AddLocal(sdka);
+            avatars.Add(sdka);
+        }
+
+        testAvatars = avatars;
+#else
+        testAvatars = new List<ApiAvatar>();
+#endif
+    }
+
+    private static void FetchWorlds(int offset = 0)
+    {
+        ApiWorld.FetchList(
+            delegate (IEnumerable<ApiWorld> obj)
+            {
+                if (obj.FirstOrDefault() != null)
+                    fetchingWorlds = EditorCoroutine.Start(() =>
+                    {
+                        var l = obj.ToList();
+                        int count = l.Count;
+                        SetupWorldData(l);
+                        FetchWorlds(offset + count);
+                    });
+                else
+                {
+                    fetchingWorlds = null;
+
+                    foreach (ApiWorld w in uploadedWorlds)
+                        DownloadImage(w.id, w.thumbnailImageUrl);
+                }
+            },
+            delegate (string obj)
+            {
+                Debug.LogError("Error fetching your uploaded worlds:\n" + obj);
+                fetchingWorlds = null;
+            },
+            ApiWorld.SortHeading.Updated,
+            ApiWorld.SortOwnership.Mine,
+            ApiWorld.SortOrder.Descending,
+            offset,
+            PageLimit,
+            "",
+            null,
+            null,
+            null,
+            "",
+            ApiWorld.ReleaseStatus.All,
+            null,
+            null, 
+            true,
+            false);
+    }
+
+    static void SetupWorldData(List<ApiWorld> worlds)
+    {
+        if (worlds == null || uploadedWorlds == null)
+            return;
+
+        worlds.RemoveAll(w => w == null || w.name == null || uploadedWorlds.Any(w2 => w2.id == w.id));
+
+        if (worlds.Count > 0)
+        {
+            uploadedWorlds.AddRange(worlds);
+            uploadedWorlds.Sort((w1, w2) => w1.name.CompareTo(w2.name));
+        }
+    }
+
+    static void SetupAvatarData(List<ApiAvatar> avatars)
+    {
+        if (avatars == null || uploadedAvatars == null )
+            return;
+
+        avatars.RemoveAll(a => a == null || uploadedAvatars.Any(a2 => a2.id == a.id));
+        foreach(var avatar in avatars)
+        {
+            if (string.IsNullOrEmpty(avatar.name))
+                avatar.name = "(unnamed)";
+        }
+
+        if (avatars.Count > 0)
+        {
+            uploadedAvatars.AddRange(avatars);
+            uploadedAvatars.Sort((w1, w2) => w1.name.CompareTo(w2.name));
+        }
+    }
+
+    static void DownloadImage(string id, string url)
+    {
+        if (string.IsNullOrEmpty(url))
+            return;
+        if (ImageCache.ContainsKey(id) && ImageCache[id] != null)
+            return;
+        
+        System.Action<Texture2D> onDone = (texture) =>
+        {
+            if (texture != null)
+            {
+                ImageCache[id] = texture;
+            }
+            else if (ImageCache.ContainsKey(id))
+                ImageCache.Remove(id);
+        };
+        EditorCoroutine.Start(VRCCachedWWW.Get(url, (onDone)));
+    }
+
+    Vector2 contentScrollPos;
+
+    bool OnGUIUserInfo()
+    {
+        bool updatedContent = false;
+
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+            ConfigManager.RemoteConfig.Init();
+
+        if (APIUser.IsLoggedInWithCredentials && uploadedWorlds != null && uploadedAvatars != null && testAvatars != null)
+        {
+
+            bool expandedLayout = false; // (position.width > MAX_ALL_INFORMATION_WIDTH);    // uncomment for future wide layouts
+
+            if (!expandedLayout)
+            {
+                EditorGUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+            }
+
+            GUILayout.BeginHorizontal();
+
+            GUILayout.BeginVertical(searchBarStyle);
+
+            EditorGUILayout.BeginHorizontal();
+
+            float searchFieldShrinkOffset = 30f;
+            GUILayoutOption layoutOption = (expandedLayout ? GUILayout.Width(position.width - searchFieldShrinkOffset) : GUILayout.Width(SdkWindowWidth - searchFieldShrinkOffset));
+            searchString = EditorGUILayout.TextField(searchString, GUI.skin.FindStyle("SearchTextField"), layoutOption);
+            GUIStyle searchButtonStyle = searchString == string.Empty
+                ? GUI.skin.FindStyle("SearchCancelButtonEmpty")
+                : GUI.skin.FindStyle("SearchCancelButton");
+            if (GUILayout.Button(string.Empty, searchButtonStyle))
+            {
+                searchString = string.Empty;
+                GUI.FocusControl(null);
+            }
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+            EditorGUILayout.EndHorizontal();
+
+            if (!expandedLayout)
+            {
+                GUILayout.FlexibleSpace();
+                EditorGUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+            }
+
+            layoutOption = (expandedLayout ? GUILayout.Width(position.width) : GUILayout.Width(SdkWindowWidth));
+            contentScrollPos = EditorGUILayout.BeginScrollView(contentScrollPos, layoutOption);
+
+            GUIStyle descriptionStyle = new GUIStyle(EditorStyles.wordWrappedLabel);
+            descriptionStyle.wordWrap = true;
+
+            if (uploadedWorlds.Count > 0)
+            {
+                EditorGUILayout.Space();
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("WORLDS", EditorStyles.boldLabel, GUILayout.ExpandWidth(false), GUILayout.Width(58));
+                WorldsToggle = EditorGUILayout.Foldout(WorldsToggle, new GUIContent(""));
+                EditorGUILayout.EndHorizontal();
+                
+                EditorGUILayout.Space();
+
+                if (WorldsToggle)
+                {
+
+                    List<ApiWorld> tmpWorlds = new List<ApiWorld>();
+
+                    if (uploadedWorlds.Count > 0)
+                        tmpWorlds = new List<ApiWorld>(uploadedWorlds);
+
+                    foreach (ApiWorld w in tmpWorlds)
+                    {
+                        if (justDeletedContents != null && justDeletedContents.Contains(w.id))
+                        {
+                            uploadedWorlds.Remove(w);
+                            continue;
+                        }
+
+                        if (!w.name.ToLowerInvariant().Contains(searchString.ToLowerInvariant()))
+                        {
+                            continue;
+                        }
+
+                        EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
+                        EditorGUILayout.BeginHorizontal(GUILayout.Width(WORLD_IMAGE_BUTTON_WIDTH));
+
+                        if (ImageCache.ContainsKey(w.id))
+                        {
+                            if (GUILayout.Button(ImageCache[w.id], GUILayout.Height(WORLD_IMAGE_BUTTON_HEIGHT),
+                                GUILayout.Width(WORLD_IMAGE_BUTTON_WIDTH)))
+                            {
+                                Application.OpenURL(w.imageUrl);
+                            }
+                        }
+                        else
+                        {
+                            if (GUILayout.Button("", GUILayout.Height(WORLD_IMAGE_BUTTON_HEIGHT),
+                                GUILayout.Width(WORLD_IMAGE_BUTTON_WIDTH)))
+                            {
+                                Application.OpenURL(w.imageUrl);
+                            }
+                        }
+
+                        if (expandedLayout)
+                        {
+                            EditorGUILayout.BeginHorizontal();
+                            EditorGUILayout.LabelField(w.name, descriptionStyle,
+                                GUILayout.Width(position.width - MAX_ALL_INFORMATION_WIDTH +
+                                                WORLD_DESCRIPTION_FIELD_WIDTH));
+                        }
+                        else
+                        {
+                            EditorGUILayout.BeginVertical();
+                            EditorGUILayout.LabelField(w.name, descriptionStyle);
+                        }
+
+                        EditorGUILayout.LabelField("Release Status: " + w.releaseStatus,
+                            GUILayout.Width(WORLD_RELEASE_STATUS_FIELD_WIDTH));
+                        if (GUILayout.Button("Copy ID", GUILayout.Width(COPY_WORLD_ID_BUTTON_WIDTH)))
+                        {
+                            TextEditor te = new TextEditor();
+                            te.text = w.id;
+                            te.SelectAll();
+                            te.Copy();
+                        }
+
+                        if (GUILayout.Button("Delete", GUILayout.Width(DELETE_WORLD_BUTTON_WIDTH)))
+                        {
+                            if (EditorUtility.DisplayDialog("Delete " + w.name + "?",
+                                "Are you sure you want to delete " + w.name + "? This cannot be undone.", "Delete",
+                                "Cancel"))
+                            {
+                                foreach (VRC.Core.PipelineManager pm in FindObjectsOfType<VRC.Core.PipelineManager>()
+                                    .Where(pm => pm.blueprintId == w.id))
+                                {
+                                    pm.blueprintId = "";
+                                    pm.completedSDKPipeline = false;
+
+                                    UnityEditor.EditorUtility.SetDirty(pm);
+                                    UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(pm.gameObject.scene);
+                                    UnityEditor.SceneManagement.EditorSceneManager.SaveScene(pm.gameObject.scene);
+                                }
+
+                                API.Delete<ApiWorld>(w.id);
+                                uploadedWorlds.RemoveAll(world => world.id == w.id);
+                                if (ImageCache.ContainsKey(w.id))
+                                    ImageCache.Remove(w.id);
+
+                                if (justDeletedContents == null) justDeletedContents = new List<string>();
+                                justDeletedContents.Add(w.id);
+                                updatedContent = true;
+                            }
+                        }
+
+                        if (expandedLayout)
+                            EditorGUILayout.EndHorizontal();
+                        else
+                            EditorGUILayout.EndVertical();
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.Space();
+                    }
+                }
+            }
+
+            if (uploadedAvatars.Count > 0)
+            {
+                EditorGUILayout.Space();
+                
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("AVATARS", EditorStyles.boldLabel, GUILayout.ExpandWidth(false), GUILayout.Width(65));
+                AvatarsToggle = EditorGUILayout.Foldout(AvatarsToggle, new GUIContent(""));
+                EditorGUILayout.EndHorizontal();
+                
+                EditorGUILayout.Space();
+
+                if (AvatarsToggle)
+                {
+
+                    List<ApiAvatar> tmpAvatars = new List<ApiAvatar>();
+
+                    if (uploadedAvatars.Count > 0)
+                        tmpAvatars = new List<ApiAvatar>(uploadedAvatars);
+
+                    if (justUpdatedAvatars != null)
+                    {
+                        foreach (ApiAvatar a in justUpdatedAvatars)
+                        {
+                            int index = tmpAvatars.FindIndex((av) => av.id == a.id);
+                            if (index != -1)
+                                tmpAvatars[index] = a;
+                        }
+                    }
+
+                    foreach (ApiAvatar a in tmpAvatars)
+                    {
+                        if (justDeletedContents != null && justDeletedContents.Contains(a.id))
+                        {
+                            uploadedAvatars.Remove(a);
+                            continue;
+                        }
+                        
+                        if (!a.name.ToLowerInvariant().Contains(searchString.ToLowerInvariant()))
+                        {
+                            continue;
+                        }
+
+                        EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
+                        EditorGUILayout.BeginHorizontal(GUILayout.Width(AVATAR_DESCRIPTION_FIELD_WIDTH));
+                        if (ImageCache.ContainsKey(a.id))
+                        {
+                            if (GUILayout.Button(ImageCache[a.id], GUILayout.Height(AVATAR_IMAGE_BUTTON_HEIGHT),
+                                GUILayout.Width(AVATAR_IMAGE_BUTTON_WIDTH)))
+                            {
+                                Application.OpenURL(a.imageUrl);
+                            }
+                        }
+                        else
+                        {
+                            if (GUILayout.Button("", GUILayout.Height(AVATAR_IMAGE_BUTTON_HEIGHT),
+                                GUILayout.Width(AVATAR_IMAGE_BUTTON_WIDTH)))
+                            {
+                                Application.OpenURL(a.imageUrl);
+                            }
+                        }
+
+                        if (expandedLayout)
+                            EditorGUILayout.BeginHorizontal();
+                        else
+                            EditorGUILayout.BeginVertical();
+
+                        EditorGUILayout.LabelField(a.name, descriptionStyle,
+                            GUILayout.Width(expandedLayout
+                                ? position.width - MAX_ALL_INFORMATION_WIDTH + AVATAR_DESCRIPTION_FIELD_WIDTH
+                                : AVATAR_DESCRIPTION_FIELD_WIDTH));
+                        EditorGUILayout.LabelField("Release Status: " + a.releaseStatus,
+                            GUILayout.Width(AVATAR_RELEASE_STATUS_FIELD_WIDTH));
+
+                        string oppositeReleaseStatus = a.releaseStatus == "public" ? "private" : "public";
+                        if (GUILayout.Button("Make " + oppositeReleaseStatus,
+                            GUILayout.Width(SET_AVATAR_STATUS_BUTTON_WIDTH)))
+                        {
+                            a.releaseStatus = oppositeReleaseStatus;
+
+                            a.SaveReleaseStatus((c) =>
+                                {
+                                    ApiAvatar savedBP = (ApiAvatar) c.Model;
+
+                                    if (justUpdatedAvatars == null) justUpdatedAvatars = new List<ApiAvatar>();
+                                    justUpdatedAvatars.Add(savedBP);
+
+                                },
+                                (c) =>
+                                {
+                                    Debug.LogError(c.Error);
+                                    EditorUtility.DisplayDialog("Avatar Updated",
+                                        "Failed to change avatar release status", "OK");
+                                });
+                        }
+
+                        if (GUILayout.Button("Copy ID", GUILayout.Width(COPY_AVATAR_ID_BUTTON_WIDTH)))
+                        {
+                            TextEditor te = new TextEditor();
+                            te.text = a.id;
+                            te.SelectAll();
+                            te.Copy();
+                        }
+
+                        if (GUILayout.Button("Delete", GUILayout.Width(DELETE_AVATAR_BUTTON_WIDTH)))
+                        {
+                            if (EditorUtility.DisplayDialog("Delete " + a.name + "?",
+                                "Are you sure you want to delete " + a.name + "? This cannot be undone.", "Delete",
+                                "Cancel"))
+                            {
+                                foreach (VRC.Core.PipelineManager pm in FindObjectsOfType<VRC.Core.PipelineManager>()
+                                    .Where(pm => pm.blueprintId == a.id))
+                                {
+                                    pm.blueprintId = "";
+                                    pm.completedSDKPipeline = false;
+
+                                    UnityEditor.EditorUtility.SetDirty(pm);
+                                    UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(pm.gameObject.scene);
+                                    UnityEditor.SceneManagement.EditorSceneManager.SaveScene(pm.gameObject.scene);
+                                }
+
+                                API.Delete<ApiAvatar>(a.id);
+                                uploadedAvatars.RemoveAll(avatar => avatar.id == a.id);
+                                if (ImageCache.ContainsKey(a.id))
+                                    ImageCache.Remove(a.id);
+
+                                if (justDeletedContents == null) justDeletedContents = new List<string>();
+                                justDeletedContents.Add(a.id);
+                                updatedContent = true;
+                            }
+                        }
+
+                        if (expandedLayout)
+                            EditorGUILayout.EndHorizontal();
+                        else
+                            EditorGUILayout.EndVertical();
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.Space();
+                    }
+                }
+            }
+
+            if (testAvatars.Count > 0)
+            {
+                EditorGUILayout.Space();
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Test Avatars", EditorStyles.boldLabel, GUILayout.ExpandWidth(false), GUILayout.Width(100));
+                TestAvatarsToggle = EditorGUILayout.Foldout(TestAvatarsToggle, new GUIContent(""));
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.Space();
+
+                if (TestAvatarsToggle)
+                {
+                    List<ApiAvatar> tmpAvatars = new List<ApiAvatar>();
+
+                    if (testAvatars.Count > 0)
+                        tmpAvatars = new List<ApiAvatar>(testAvatars);
+
+                    foreach (ApiAvatar a in tmpAvatars)
+                    {
+                        if (!a.name.ToLowerInvariant().Contains(searchString.ToLowerInvariant()))
+                        {
+                            continue;
+                        }
+
+                        EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
+
+                        if (expandedLayout)
+                            EditorGUILayout.BeginHorizontal();
+                        else
+                            EditorGUILayout.BeginVertical();
+
+                        EditorGUILayout.LabelField(a.name, descriptionStyle,
+                            GUILayout.Width(expandedLayout
+                                ? position.width - MAX_ALL_INFORMATION_WIDTH + AVATAR_DESCRIPTION_FIELD_WIDTH
+                                : AVATAR_DESCRIPTION_FIELD_WIDTH));
+
+                        if (GUILayout.Button("Delete", GUILayout.Width(DELETE_AVATAR_BUTTON_WIDTH)))
+                        {
+                            if (EditorUtility.DisplayDialog("Delete " + a.name + "?",
+                                "Are you sure you want to delete " + a.name + "? This cannot be undone.", "Delete",
+                                "Cancel"))
+                            {
+                                API.Delete<ApiAvatar>(a.id);
+                                testAvatars.RemoveAll(avatar => avatar.id == a.id);
+                                File.Delete(a.assetUrl);
+
+                                updatedContent = true;
+                            }
+                        }
+
+                        if (expandedLayout)
+                            EditorGUILayout.EndHorizontal();
+                        else
+                            EditorGUILayout.EndVertical();
+                        EditorGUILayout.EndHorizontal();
+                        EditorGUILayout.Space();
+                    }
+                }
+            }
+
+            EditorGUILayout.EndScrollView();
+            if (!expandedLayout)
+            {
+                GUILayout.FlexibleSpace();
+                GUILayout.EndHorizontal();
+            }
+            if ((updatedContent) && (null != window)) window.Reset();
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    void ShowContent()
+    {
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.BeginVertical();
+
+        if (uploadedWorlds == null || uploadedAvatars == null || testAvatars == null)
+        {
+            if (uploadedWorlds == null)
+                uploadedWorlds = new List<ApiWorld>();
+            if (uploadedAvatars == null)
+                uploadedAvatars = new List<ApiAvatar>();
+            if (testAvatars == null)
+                testAvatars = new List<ApiAvatar>();
+
+            EditorCoroutine.Start(FetchUploadedData());
+        }
+
+        if( fetchingWorlds != null || fetchingAvatars != null )
+        {
+            GUILayout.BeginVertical(boxGuiStyle, GUILayout.Width(SdkWindowWidth));
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Fetching Records", titleGuiStyle);
+            EditorGUILayout.Space();
+            GUILayout.EndVertical();
+        }
+        else
+        {
+            GUILayout.BeginVertical(boxGuiStyle, GUILayout.Width(SdkWindowWidth));
+            EditorGUILayout.Space();
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Label("Fetch updated records from the VRChat server");
+            if( GUILayout.Button("Fetch") )
+            {
+                ClearContent();
+            }
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.Space();
+            GUILayout.EndVertical();
+        }
+
+        GUILayout.EndVertical();
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+
+        OnGUIUserInfo();
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelContent.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c7333cdb3df19724b84b4a1b05093fe0
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelHelp.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using VRC;
+using VRC.Core;
+using VRC.SDKBase;
+
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    [MenuItem("VRChat SDK/Help/Developer FAQ")]
+    public static void ShowDeveloperFAQ()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+        {
+            ConfigManager.RemoteConfig.Init(() => ShowDeveloperFAQ());
+            return;
+        }
+
+        Application.OpenURL(ConfigManager.RemoteConfig.GetString("sdkDeveloperFaqUrl"));
+    }
+
+    [MenuItem("VRChat SDK/Help/VRChat Discord")]
+    public static void ShowVRChatDiscord()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+        {
+            ConfigManager.RemoteConfig.Init(() => ShowVRChatDiscord());
+            return;
+        }
+
+        Application.OpenURL(ConfigManager.RemoteConfig.GetString("sdkDiscordUrl"));
+    }
+
+    [MenuItem("VRChat SDK/Help/Avatar Optimization Tips")]
+    public static void ShowAvatarOptimizationTips()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+        {
+            ConfigManager.RemoteConfig.Init(() => ShowAvatarOptimizationTips());
+            return;
+        }
+
+        Application.OpenURL(AVATAR_OPTIMIZATION_TIPS_URL);
+    }
+
+    [MenuItem("VRChat SDK/Help/Avatar Rig Requirements")]
+    public static void ShowAvatarRigRequirements()
+    {
+        if (!ConfigManager.RemoteConfig.IsInitialized())
+        {
+            ConfigManager.RemoteConfig.Init(() => ShowAvatarRigRequirements());
+            return;
+        }
+
+        Application.OpenURL(AVATAR_RIG_REQUIREMENTS_URL);
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelHelp.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f3507a74e4b8cfd469afac127fa5f4e5
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelSettings.cs

@@ -0,0 +1,265 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using VRC.Core;
+
+public partial class VRCSdkControlPanel : EditorWindow
+{
+    bool UseDevApi
+    {
+        get
+        {
+            return VRC.Core.API.GetApiUrl() == VRC.Core.API.devApiUrl;
+        }
+    }
+
+    string clientVersionDate;
+    string sdkVersionDate;
+    Vector2 settingsScroll;
+
+    private void Awake()
+    {
+        GetClientSdkVersionInformation();
+    }
+
+    public void GetClientSdkVersionInformation()
+    {
+        clientVersionDate = VRC.Core.SDKClientUtilities.GetTestClientVersionDate();
+        sdkVersionDate = VRC.Core.SDKClientUtilities.GetSDKVersionDate();
+    }
+
+    public void OnConfigurationChanged()
+    {
+        GetClientSdkVersionInformation();
+    }
+
+    void ShowSettings()
+    {
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.BeginVertical();
+
+        settingsScroll = EditorGUILayout.BeginScrollView(settingsScroll, GUILayout.Width(SdkWindowWidth));
+
+        EditorGUILayout.BeginVertical(boxGuiStyle);
+        EditorGUILayout.LabelField("Developer", EditorStyles.boldLabel);
+#if VRC_SDK_VRCSDK2
+        VRCSettings.Get().DisplayAdvancedSettings = EditorGUILayout.ToggleLeft("Show Extra Options on build page and account page", VRCSettings.Get().DisplayAdvancedSettings);
+        bool prevDisplayHelpBoxes = VRCSettings.Get().DisplayHelpBoxes;
+        VRCSettings.Get().DisplayHelpBoxes = EditorGUILayout.ToggleLeft("Show Help Boxes on SDK components", VRCSettings.Get().DisplayHelpBoxes);
+        if (VRCSettings.Get().DisplayHelpBoxes != prevDisplayHelpBoxes)
+#elif VRC_SDK_VRCSDK3
+        VRC.SDK3.Editor.VRCSettings.Get().DisplayAdvancedSettings = EditorGUILayout.ToggleLeft("Show Extra Options on build page and account page", VRC.SDK3.Editor.VRCSettings.Get().DisplayAdvancedSettings);
+        bool prevDisplayHelpBoxes = VRC.SDK3.Editor.VRCSettings.Get().DisplayHelpBoxes;
+        VRC.SDK3.Editor.VRCSettings.Get().DisplayHelpBoxes = EditorGUILayout.ToggleLeft("Show Help Boxes on SDK components", VRC.SDK3.Editor.VRCSettings.Get().DisplayHelpBoxes);
+        if (VRC.SDK3.Editor.VRCSettings.Get().DisplayHelpBoxes != prevDisplayHelpBoxes)
+#endif
+        {
+            Editor[] editors = (Editor[])Resources.FindObjectsOfTypeAll<Editor>();
+            for (int i = 0; i < editors.Length; i++)
+            {
+                editors[i].Repaint();
+            }
+        }
+        EditorGUILayout.EndVertical();
+
+        EditorGUILayout.Separator();
+
+        ShowSdk23CompatibilitySettings();
+        EditorGUILayout.Separator();
+
+        ShowSettingsOptionsForBuilders();
+        
+
+        // debugging
+        if (APIUser.CurrentUser != null && APIUser.CurrentUser.hasSuperPowers)
+        {
+            EditorGUILayout.Separator();
+            EditorGUILayout.BeginVertical(boxGuiStyle);
+
+            EditorGUILayout.LabelField("Logging", EditorStyles.boldLabel);
+
+            // API logging
+            {
+                bool isLoggingEnabled = UnityEditor.EditorPrefs.GetBool("apiLoggingEnabled");
+                bool enableLogging = EditorGUILayout.ToggleLeft("API Logging Enabled", isLoggingEnabled);
+                if (enableLogging != isLoggingEnabled)
+                {
+                    if (enableLogging)
+                        VRC.Core.Logger.AddDebugLevel(DebugLevel.API);
+                    else
+                        VRC.Core.Logger.RemoveDebugLevel(DebugLevel.API);
+
+                    UnityEditor.EditorPrefs.SetBool("apiLoggingEnabled", enableLogging);
+                }
+            }
+
+            // All logging
+            {
+                bool isLoggingEnabled = UnityEditor.EditorPrefs.GetBool("allLoggingEnabled");
+                bool enableLogging = EditorGUILayout.ToggleLeft("All Logging Enabled", isLoggingEnabled);
+                if (enableLogging != isLoggingEnabled)
+                {
+                    if (enableLogging)
+                        VRC.Core.Logger.AddDebugLevel(DebugLevel.All);
+                    else
+                        VRC.Core.Logger.RemoveDebugLevel(DebugLevel.All);
+
+                    UnityEditor.EditorPrefs.SetBool("allLoggingEnabled", enableLogging);
+                }
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else
+        {
+            if (UnityEditor.EditorPrefs.GetBool("apiLoggingEnabled"))
+                UnityEditor.EditorPrefs.SetBool("apiLoggingEnabled", false);
+            if (UnityEditor.EditorPrefs.GetBool("allLoggingEnabled"))
+                UnityEditor.EditorPrefs.SetBool("allLoggingEnabled", false);
+        }
+
+        // Future proof upload
+        {
+            EditorGUILayout.Separator();
+            EditorGUILayout.BeginVertical(boxGuiStyle);
+
+            EditorGUILayout.LabelField("Publish", EditorStyles.boldLabel);
+            bool futureProofPublish = UnityEditor.EditorPrefs.GetBool("futureProofPublish", DefaultFutureProofPublishEnabled);
+
+            futureProofPublish = EditorGUILayout.ToggleLeft("Future Proof Publish", futureProofPublish);
+
+            if (UnityEditor.EditorPrefs.GetBool("futureProofPublish", DefaultFutureProofPublishEnabled) != futureProofPublish)
+            {
+                UnityEditor.EditorPrefs.SetBool("futureProofPublish", futureProofPublish);
+            }
+            EditorGUILayout.LabelField("Client Version Date", clientVersionDate);
+            EditorGUILayout.LabelField("SDK Version Date", sdkVersionDate);
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+        if (APIUser.CurrentUser != null)
+        {
+            EditorGUILayout.Separator();
+            EditorGUILayout.BeginVertical(boxGuiStyle);
+
+            // custom vrchat install location
+            OnVRCInstallPathGUI();
+
+            EditorGUILayout.EndVertical();
+        }
+
+        EditorGUILayout.EndScrollView();
+
+        GUILayout.EndVertical();
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+    }
+
+    static void OnVRCInstallPathGUI()
+    {
+        EditorGUILayout.LabelField("VRChat Client", EditorStyles.boldLabel);
+        EditorGUILayout.LabelField("Installed Client Path: ", clientInstallPath);
+        EditorGUILayout.BeginHorizontal();
+        GUILayout.Label("");
+        if (GUILayout.Button("Edit"))
+        {
+            string initPath = "";
+            if (!string.IsNullOrEmpty(clientInstallPath))
+                initPath = clientInstallPath;
+
+            clientInstallPath = EditorUtility.OpenFilePanel("Choose VRC Client Exe", initPath, "exe");
+            SDKClientUtilities.SetVRCInstallPath(clientInstallPath);
+            window.OnConfigurationChanged();
+        }
+        if (GUILayout.Button("Revert to Default"))
+        {
+            clientInstallPath = SDKClientUtilities.LoadRegistryVRCInstallPath();
+            window.OnConfigurationChanged();
+        }
+        EditorGUILayout.EndHorizontal();
+
+        EditorGUILayout.Separator();
+    }
+
+    static void ShowSdk23CompatibilitySettings()
+    {
+        return;
+
+//        EditorGUILayout.BeginVertical(boxGuiStyle);
+//        EditorGUILayout.LabelField("VRCSDK2 & VRCSDK3 Compatibility", EditorStyles.boldLabel);
+
+//#if !VRC_CLIENT
+//        bool sdk2Present = VRCSdk3Analysis.GetSDKInScene(VRCSdk3Analysis.SdkVersion.VRCSDK2).Count > 0;
+//        bool sdk3Present = VRCSdk3Analysis.GetSDKInScene(VRCSdk3Analysis.SdkVersion.VRCSDK3).Count > 0;
+//        bool sdk2DllActive = VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK2);
+//        bool sdk3DllActive = VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+
+//        if ( sdk2DllActive && sdk3DllActive)
+//        {
+//            GUILayout.TextArea("You have not yet configured this project for development with VRCSDK2 and Triggers or VRCSDK3 and Udon. ");
+//            if (sdk2Present && sdk3Present)
+//            {
+//                GUILayout.TextArea("This scene contains both SDK2 and SDK3 elements. " +
+//                    "Please modify this scene to contain only one type or the other before completing your configuration.");
+//            }
+//            else if (sdk2Present)
+//            {
+//                GUILayout.TextArea("This scene contains SDK2 scripts. " +
+//                    "Check below to configure this project for use with VRCSDK2 or remove your VRCSDK2 scripts to upgrade to VRCSDK3");
+//                bool downgrade = EditorGUILayout.ToggleLeft("Configure for use with VRCSDK2 and Triggers", false);
+//                if (downgrade)
+//                    VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK2);
+//            }
+//            else if (sdk3Present)
+//            {
+//                GUILayout.TextArea("This scene contains only SDK3 scripts and it ready to upgrade. " +
+//                    "Click below to get started.");
+//                bool upgrade = EditorGUILayout.ToggleLeft("Configure for use with VRCSDK3 and Udon - Let's Rock!", false);
+//                if (upgrade)
+//                    VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+//            }
+//            else
+//            {
+//                GUILayout.TextArea("This scene is a blank slate. " +
+//                    "Click below to get started.");
+//                bool upgrade = EditorGUILayout.ToggleLeft("Configure for use with VRCSDK3 and Udon - Let's Rock!", false);
+//                if (upgrade)
+//                    VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+//            }
+//        }
+//        else if (sdk2DllActive)
+//        {
+//            GUILayout.TextArea("This project has been configured to be built with VRCSDK2. " +
+//                "To upgrade, VRCSDK3 must be enabled here.");
+//            bool upgrade = EditorGUILayout.ToggleLeft("VRCSDK3 Scripts can be used", false);
+//            if (upgrade)
+//                VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+//        }
+//        else if (sdk3DllActive)
+//        {
+//            GUILayout.TextArea("This project has been configured to be built with VRCSDK3. " +
+//                "Congratulations, you're ready to go. " +
+//                "You can still downgrade by activating VRCSDK2 here.");
+//            bool downgrade = EditorGUILayout.ToggleLeft("VRCSDK2 Scripts can be used", false);
+//            if (downgrade)
+//                VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK2);
+//        }
+//        else
+//        {
+//            GUILayout.TextArea("Somehow you have disabled both VRCSDK2 and VRCSDK3. Oops. " +
+//                "Click here to begin development with VRCSDK3.");
+//            bool begin = EditorGUILayout.ToggleLeft("VRCSDK3 Scripts can be used", false);
+//            if (begin)
+//                VRCSdk3Analysis.SetSdkVersionActive(VRCSdk3Analysis.SdkVersion.VRCSDK3);
+//        }
+//#else
+//        GUILayout.TextArea("I think you're in the main VRChat project. " +
+//            "You should not be enabling or disabling SDKs from here.");
+//#endif
+
+//        EditorGUILayout.EndVertical();
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelSettings.cs.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8357b9b7ef2416946ae86f465a64c0e0
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/ControlPanel/VRCSdkControlPanelWorldBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f2a720a30f1043247af7742fdfd0b8e5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/EnvConfig.cs

@@ -0,0 +1,773 @@
+#define ENV_SET_INCLUDED_SHADERS
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine.Rendering;
+using VRCSDK2.Validation.Performance.Stats;
+
+/// <summary>
+/// Setup up SDK env on editor launch
+/// </summary>
+[InitializeOnLoad]
+public class EnvConfig
+{
+    static BuildTarget[] relevantBuildTargets = new BuildTarget[] {
+        BuildTarget.Android, BuildTarget.iOS,
+        BuildTarget.StandaloneLinux64,
+        BuildTarget.StandaloneWindows, BuildTarget.StandaloneWindows64,
+        BuildTarget.StandaloneOSX
+    };
+
+#if !VRC_CLIENT
+    static BuildTarget[] allowedBuildtargets = new BuildTarget[]
+    {
+        BuildTarget.StandaloneWindows64,
+        BuildTarget.Android
+    };
+#endif
+
+    static System.Collections.Generic.Dictionary<BuildTarget, UnityEngine.Rendering.GraphicsDeviceType[]> allowedGraphicsAPIs = new System.Collections.Generic.Dictionary<BuildTarget, UnityEngine.Rendering.GraphicsDeviceType[]>()
+    {
+        { BuildTarget.Android, new [] { GraphicsDeviceType.OpenGLES3, /* GraphicsDeviceType.Vulkan */ }},
+        { BuildTarget.iOS, null },
+        { BuildTarget.StandaloneLinux64, null },
+        { BuildTarget.StandaloneWindows, new UnityEngine.Rendering.GraphicsDeviceType[] { UnityEngine.Rendering.GraphicsDeviceType.Direct3D11 } },
+        { BuildTarget.StandaloneWindows64, new UnityEngine.Rendering.GraphicsDeviceType[] { UnityEngine.Rendering.GraphicsDeviceType.Direct3D11 } },
+        { BuildTarget.StandaloneOSX, null }
+    };
+
+#if ENV_SET_INCLUDED_SHADERS && VRC_CLIENT
+    static string[] ensureTheseShadersAreAvailable = new string[]
+    {
+        "Hidden/CubeBlend",
+        "Hidden/CubeBlur",
+        "Hidden/CubeCopy",
+        "Hidden/VideoDecode",
+        "Legacy Shaders/Bumped Diffuse",
+        "Legacy Shaders/Bumped Specular",
+        "Legacy Shaders/Decal",
+        "Legacy Shaders/Diffuse Detail",
+        "Legacy Shaders/Diffuse Fast",
+        "Legacy Shaders/Diffuse",
+        "Legacy Shaders/Diffuse",
+        "Legacy Shaders/Lightmapped/Diffuse",
+        "Legacy Shaders/Lightmapped/Specular",
+        "Legacy Shaders/Lightmapped/VertexLit",
+        "Legacy Shaders/Parallax Diffuse",
+        "Legacy Shaders/Parallax Specular",
+        "Legacy Shaders/Reflective/Bumped Diffuse",
+        "Legacy Shaders/Reflective/Bumped Specular",
+        "Legacy Shaders/Reflective/Bumped Unlit",
+        "Legacy Shaders/Reflective/Bumped VertexLit",
+        "Legacy Shaders/Reflective/Diffuse",
+        "Legacy Shaders/Reflective/Parallax Diffuse",
+        "Legacy Shaders/Reflective/Parallax Specular",
+        "Legacy Shaders/Reflective/Specular",
+        "Legacy Shaders/Reflective/VertexLit",
+        "Legacy Shaders/Self-Illumin/Bumped Diffuse",
+        "Legacy Shaders/Self-Illumin/Bumped Specular",
+        "Legacy Shaders/Self-Illumin/Diffuse",
+        "Legacy Shaders/Self-Illumin/Parallax Diffuse",
+        "Legacy Shaders/Self-Illumin/Parallax Specular",
+        "Legacy Shaders/Self-Illumin/Specular",
+        "Legacy Shaders/Self-Illumin/VertexLit",
+        "Legacy Shaders/Specular",
+        "Legacy Shaders/Transparent/Bumped Diffuse",
+        "Legacy Shaders/Transparent/Bumped Specular",
+        "Legacy Shaders/Transparent/Cutout/Bumped Diffuse",
+        "Legacy Shaders/Transparent/Cutout/Bumped Specular",
+        "Legacy Shaders/Transparent/Cutout/Diffuse",
+        "Legacy Shaders/Transparent/Cutout/Soft Edge Unlit",
+        "Legacy Shaders/Transparent/Cutout/Specular",
+        "Legacy Shaders/Transparent/Cutout/VertexLit",
+        "Legacy Shaders/Transparent/Diffuse",
+        "Legacy Shaders/Transparent/Parallax Diffuse",
+        "Legacy Shaders/Transparent/Parallax Specular",
+        "Legacy Shaders/Transparent/Specular",
+        "Legacy Shaders/Transparent/VertexLit",
+        "Legacy Shaders/VertexLit",
+        "Mobile/Particles/Additive",
+        "Mobile/Particles/Alpha Blended",
+        "Mobile/Particles/Multiply",
+        "Mobile/Particles/VertexLit Blended",
+        "Mobile/Skybox",
+        "Nature/Terrain/Diffuse",
+        "Nature/Terrain/Specular",
+        "Nature/Terrain/Standard",
+        "Particles/Additive (Soft)",
+        "Particles/Additive",
+        "Particles/Alpha Blended Premultiply",
+        "Particles/Alpha Blended",
+        "Particles/Anim Alpha Blended",
+        "Particles/Multiply (Double)",
+        "Particles/Multiply",
+        "Particles/VertexLit Blended",
+        "Particles/~Additive-Multiply",
+        "Skybox/Cubemap",
+        "Skybox/Procedural",
+        "Skybox/6 Sided",
+        "Sprites/Default",
+        "Sprites/Diffuse",
+        "UI/Default",
+        "VRChat/UI/Unlit/WebPanelTransparent",
+        "Toon/Lit",
+        "Toon/Lit (Double)",
+        "Toon/Lit Cutout",
+        "Toon/Lit Cutout (Double)",
+        "Toon/Lit Outline",
+        "VRChat/Mobile/Diffuse",
+        "Video/RealtimeEmissiveGamma",
+        "VRChat/Mobile/Bumped Uniform Diffuse",
+        "VRChat/Mobile/Bumped Uniform Specular",
+        "VRChat/Mobile/Toon Lit",
+        "VRChat/Mobile/MatCap Lit",
+        "VRChat/Mobile/Skybox",
+        "VRChat/Mobile/Lightmapped",
+        "VRChat/PC/Toon Lit",
+        "VRChat/PC/Toon Lit (Double)",
+        "VRChat/PC/Toon Lit Cutout",
+        "VRChat/PC/Toon Lit Cutout (Double)",
+        "Unlit/Color",
+        "Unlit/Transparent",
+        "Unlit/Transparent Cutout",
+        "Unlit/Texture",
+        "MatCap/Vertex/Textured Lit",
+    };
+#endif
+
+    private static bool _requestConfigureSettings = true;
+
+    static EnvConfig()
+    {
+        EditorApplication.update += EditorUpdate;
+    }
+
+    static void EditorUpdate()
+    {
+        if (_requestConfigureSettings)
+        {
+            if (ConfigureSettings())
+            {
+                _requestConfigureSettings = false;
+            }
+        }
+    }
+
+    public static void RequestConfigureSettings()
+    {
+        _requestConfigureSettings = true;
+    }
+
+    [UnityEditor.Callbacks.DidReloadScripts(int.MaxValue)]
+    static void DidReloadScripts()
+    {
+        RequestConfigureSettings();
+    }
+
+    public static bool ConfigureSettings()
+    {
+        CheckForFirstInit();
+
+        if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isUpdating)
+            return false;
+
+        ConfigurePlayerSettings();
+
+        if (!VRC.Core.ConfigManager.RemoteConfig.IsInitialized())
+        {
+            VRC.Core.API.SetOnlineMode(true, "vrchat");
+            VRC.Core.ConfigManager.RemoteConfig.Init();
+        }
+
+        LoadEditorResources();
+
+        return true;
+    }
+
+    static void SetDLLPlatforms(string dllName, bool active)
+    {
+        string[] assetGuids = AssetDatabase.FindAssets(dllName);
+
+        foreach (string guid in assetGuids)
+        {
+            string dllPath = AssetDatabase.GUIDToAssetPath(guid);
+            if (string.IsNullOrEmpty(dllPath) || dllPath.ToLower().EndsWith(".dll") == false)
+                return;
+
+            PluginImporter importer = AssetImporter.GetAtPath(dllPath) as PluginImporter;
+
+            bool allCorrect = true;
+            if (importer.GetCompatibleWithAnyPlatform() != active)
+            {
+                allCorrect = false;
+            }
+            else
+            {
+                if (importer.GetCompatibleWithAnyPlatform())
+                {
+                    if (importer.GetExcludeEditorFromAnyPlatform() != !active ||
+                        importer.GetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows) != !active)
+                    {
+                        allCorrect = false;
+                    }
+                }
+                else
+                {
+                    if (importer.GetCompatibleWithEditor() != active ||
+                        importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows) != active)
+                    {
+                        allCorrect = false;
+                    }
+
+                }
+            }
+
+            if (allCorrect == false)
+            {
+                if (active)
+                {
+                    importer.SetCompatibleWithAnyPlatform(true);
+                    importer.SetExcludeEditorFromAnyPlatform(false);
+                    importer.SetExcludeFromAnyPlatform(BuildTarget.Android, false);
+                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows, false);
+                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows64, false);
+                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneLinux64, false);
+                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneOSX, false);
+                }
+                else
+                {
+                    importer.SetCompatibleWithAnyPlatform(false);
+                    importer.SetCompatibleWithEditor(false);
+                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
+                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
+                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
+                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
+                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
+                }
+                importer.SaveAndReimport();
+            }
+        }
+    }
+
+    [MenuItem("VRChat SDK/Utilities/Force Configure Player Settings")]
+    public static void ConfigurePlayerSettings()
+    {
+        VRC.Core.Logger.Log("Setting required PlayerSettings...", VRC.Core.DebugLevel.All);
+
+        SetBuildTarget();
+
+        // Needed for Microsoft.CSharp namespace in DLLMaker
+        // Doesn't seem to work though
+        if (PlayerSettings.GetApiCompatibilityLevel(EditorUserBuildSettings.selectedBuildTargetGroup) != ApiCompatibilityLevel.NET_4_6)
+            PlayerSettings.SetApiCompatibilityLevel(EditorUserBuildSettings.selectedBuildTargetGroup, ApiCompatibilityLevel.NET_4_6);
+
+        if (!PlayerSettings.runInBackground)
+            PlayerSettings.runInBackground = true;
+
+#if !VRC_CLIENT
+        SetDLLPlatforms("VRCCore-Standalone", false);
+        SetDLLPlatforms("VRCCore-Editor", true);
+#endif
+
+        SetDefaultGraphicsAPIs();
+        SetGraphicsSettings();
+        SetAudioSettings();
+        SetPlayerSettings();
+
+#if VRC_CLIENT
+        PlatformSwitcher.RefreshRequiredPackages(EditorUserBuildSettings.selectedBuildTargetGroup);
+
+        AssetDatabase.SaveAssets();
+        AssetDatabase.Refresh();
+#else
+        // SDK
+
+		// default to steam runtime in sdk (shouldn't matter)
+		SetVRSDKs(EditorUserBuildSettings.selectedBuildTargetGroup, new string[] { "None", "OpenVR", "Oculus" });
+
+        VRC.Core.AnalyticsSDK.Initialize(VRC.Core.SDKClientUtilities.GetSDKVersionDate());
+#endif
+
+        #if VRC_CLIENT
+        // VRCLog should handle disk writing
+        PlayerSettings.usePlayerLog = false;
+        foreach (LogType logType in Enum.GetValues(typeof(LogType)).Cast<LogType>())
+        {
+            switch(logType)
+            {
+                case LogType.Assert:
+                case LogType.Exception:
+                {
+                    PlayerSettings.SetStackTraceLogType(logType, StackTraceLogType.ScriptOnly);
+                    break;
+                }
+                case LogType.Error:
+                case LogType.Warning:
+                case LogType.Log:
+                {
+                    PlayerSettings.SetStackTraceLogType(logType, StackTraceLogType.None);
+                    break;
+                }
+                default:
+                {
+                    throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+        #endif
+    }
+
+    static void EnableBatching(bool enable)
+    {
+        PlayerSettings[] playerSettings = Resources.FindObjectsOfTypeAll<PlayerSettings>();
+        if (playerSettings == null)
+            return;
+
+        SerializedObject playerSettingsSerializedObject = new SerializedObject(playerSettings);
+        SerializedProperty batchingSettings = playerSettingsSerializedObject.FindProperty("m_BuildTargetBatching");
+        if (batchingSettings == null)
+            return;
+
+        for (int i = 0; i < batchingSettings.arraySize; i++)
+        {
+            SerializedProperty batchingArrayValue = batchingSettings.GetArrayElementAtIndex(i);
+            if (batchingArrayValue == null)
+                continue;
+
+            IEnumerator batchingEnumerator = batchingArrayValue.GetEnumerator();
+            if (batchingEnumerator == null)
+                continue;
+
+            while (batchingEnumerator.MoveNext())
+            {
+                SerializedProperty property = (SerializedProperty)batchingEnumerator.Current;
+
+                if (property != null && property.name == "m_BuildTarget")
+                {
+                    // only change setting on "Standalone" entry
+                    if (property.stringValue != "Standalone")
+                        break;
+                }
+
+
+                if (property != null && property.name == "m_StaticBatching")
+                {
+                    property.boolValue = enable;
+                }
+
+                if (property != null && property.name == "m_DynamicBatching")
+                {
+                    property.boolValue = enable;
+                }
+            }
+        }
+
+        playerSettingsSerializedObject.ApplyModifiedProperties();
+    }
+
+    public static void SetVRSDKs(BuildTargetGroup buildTargetGroup, string[] sdkNames)
+    {
+        VRC.Core.Logger.Log("Setting virtual reality SDKs in PlayerSettings: ", VRC.Core.DebugLevel.All);
+        if (sdkNames != null)
+        {
+            foreach (string s in sdkNames)
+                VRC.Core.Logger.Log("- " + s, VRC.Core.DebugLevel.All);
+        }
+
+        PlayerSettings.SetVirtualRealitySDKs(buildTargetGroup, sdkNames);
+    }
+
+    public static bool CheckForFirstInit()
+    {
+        bool firstLaunch = UnityEditor.SessionState.GetBool("EnvConfigFirstLaunch", true);
+        if (firstLaunch)
+            UnityEditor.SessionState.SetBool("EnvConfigFirstLaunch", false);
+
+        return firstLaunch;
+    }
+
+    static void SetDefaultGraphicsAPIs()
+    {
+        VRC.Core.Logger.Log("Setting Graphics APIs", VRC.Core.DebugLevel.All);
+        foreach (BuildTarget target in relevantBuildTargets)
+        {
+            var apis = allowedGraphicsAPIs[target];
+            if (apis == null)
+                SetGraphicsAPIs(target, true);
+            else
+                SetGraphicsAPIs(target, false, apis);
+        }
+    }
+
+    static void SetGraphicsAPIs(BuildTarget platform, bool auto, UnityEngine.Rendering.GraphicsDeviceType[] allowedTypes = null)
+    {
+        try
+        {
+            if (auto != PlayerSettings.GetUseDefaultGraphicsAPIs(platform))
+                PlayerSettings.SetUseDefaultGraphicsAPIs(platform, auto);
+        }
+        catch { }
+
+        try
+        {
+            UnityEngine.Rendering.GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
+            if (((allowedTypes == null || allowedTypes.Length == 0) &&
+                 (graphicsAPIs != null || graphicsAPIs.Length != 0))
+                || !allowedTypes.SequenceEqual(graphicsAPIs))
+            {
+                if (allowedTypes == null)
+                {
+                    allowedTypes =  PlayerSettings.GetGraphicsAPIs(platform);
+                }
+                PlayerSettings.SetGraphicsAPIs(platform, allowedTypes);   
+            }
+        }
+        catch { }
+    }
+
+    static void SetGraphicsSettings()
+    {
+        VRC.Core.Logger.Log("Setting Graphics Settings", VRC.Core.DebugLevel.All);
+
+        const string GraphicsSettingsAssetPath = "ProjectSettings/GraphicsSettings.asset";
+        SerializedObject graphicsManager = new SerializedObject(UnityEditor.AssetDatabase.LoadAllAssetsAtPath(GraphicsSettingsAssetPath)[0]);
+
+        SerializedProperty deferred = graphicsManager.FindProperty("m_Deferred.m_Mode");
+        deferred.enumValueIndex = 1;
+
+        SerializedProperty deferredReflections = graphicsManager.FindProperty("m_DeferredReflections.m_Mode");
+        deferredReflections.enumValueIndex = 1;
+
+        SerializedProperty screenSpaceShadows = graphicsManager.FindProperty("m_ScreenSpaceShadows.m_Mode");
+        screenSpaceShadows.enumValueIndex = 1;
+
+        SerializedProperty legacyDeferred = graphicsManager.FindProperty("m_LegacyDeferred.m_Mode");
+        legacyDeferred.enumValueIndex = 1;
+
+        SerializedProperty depthNormals = graphicsManager.FindProperty("m_DepthNormals.m_Mode");
+        depthNormals.enumValueIndex = 1;
+
+        SerializedProperty motionVectors = graphicsManager.FindProperty("m_MotionVectors.m_Mode");
+        motionVectors.enumValueIndex = 1;
+
+        SerializedProperty lightHalo = graphicsManager.FindProperty("m_LightHalo.m_Mode");
+        lightHalo.enumValueIndex = 1;
+
+        SerializedProperty lensFlare = graphicsManager.FindProperty("m_LensFlare.m_Mode");
+        lensFlare.enumValueIndex = 1;
+
+#if ENV_SET_INCLUDED_SHADERS && VRC_CLIENT
+        SerializedProperty alwaysIncluded = graphicsManager.FindProperty("m_AlwaysIncludedShaders");
+        alwaysIncluded.arraySize = 0;   // clear GraphicsSettings->Always Included Shaders - these cause a +5s app startup time increase on Quest.
+                                        // include Shader objects as resources instead
+
+#if ENV_SEARCH_FOR_SHADERS
+        Resources.LoadAll("", typeof(Shader));
+        System.Collections.Generic.List<Shader> foundShaders = Resources.FindObjectsOfTypeAll<Shader>()
+            .Where(s => { string name = s.name.ToLower(); return 0 == (s.hideFlags & HideFlags.DontSave); })
+            .GroupBy(s => s.name)
+            .Select(g => g.First())
+            .ToList();
+#else
+        System.Collections.Generic.List<Shader> foundShaders = new System.Collections.Generic.List<Shader>();
+#endif
+
+        for (int shaderIdx = 0; shaderIdx < ensureTheseShadersAreAvailable.Length; ++shaderIdx)
+        {
+            if (foundShaders.Any(s => s.name == ensureTheseShadersAreAvailable[shaderIdx]))
+                continue;
+            Shader namedShader = Shader.Find(ensureTheseShadersAreAvailable[shaderIdx]);
+            if (namedShader != null)
+                foundShaders.Add(namedShader);
+        }
+
+        foundShaders.Sort((s1, s2) => s1.name.CompareTo(s2.name));
+
+        // populate Resources list of "always included shaders"
+        ShaderAssetList alwaysIncludedShaders = AssetDatabase.LoadAssetAtPath<ShaderAssetList>("Assets/Resources/AlwaysIncludedShaders.asset");
+        alwaysIncludedShaders.Shaders = new Shader[foundShaders.Count];
+        for (int shaderIdx = 0; shaderIdx < foundShaders.Count; ++shaderIdx)
+            alwaysIncludedShaders.Shaders[shaderIdx] = foundShaders[shaderIdx];
+#endif
+
+        SerializedProperty preloaded = graphicsManager.FindProperty("m_PreloadedShaders");
+        preloaded.ClearArray();
+        preloaded.arraySize = 0;
+
+        SerializedProperty spritesDefaultMaterial = graphicsManager.FindProperty("m_SpritesDefaultMaterial");
+        spritesDefaultMaterial.objectReferenceValue = Shader.Find("Sprites/Default");
+
+        SerializedProperty renderPipeline = graphicsManager.FindProperty("m_CustomRenderPipeline");
+        renderPipeline.objectReferenceValue = null;
+
+        SerializedProperty transparencySortMode = graphicsManager.FindProperty("m_TransparencySortMode");
+        transparencySortMode.enumValueIndex = 0;
+
+        SerializedProperty transparencySortAxis = graphicsManager.FindProperty("m_TransparencySortAxis");
+        transparencySortAxis.vector3Value = Vector3.forward;
+
+        SerializedProperty defaultRenderingPath = graphicsManager.FindProperty("m_DefaultRenderingPath");
+        defaultRenderingPath.intValue = 1;
+
+        SerializedProperty defaultMobileRenderingPath = graphicsManager.FindProperty("m_DefaultMobileRenderingPath");
+        defaultMobileRenderingPath.intValue = 1;
+
+        SerializedProperty tierSettings = graphicsManager.FindProperty("m_TierSettings");
+        tierSettings.ClearArray();
+        tierSettings.arraySize = 0;
+
+#if ENV_SET_LIGHTMAP
+        SerializedProperty lightmapStripping = graphicsManager.FindProperty("m_LightmapStripping");
+        lightmapStripping.enumValueIndex = 1;
+
+        SerializedProperty instancingStripping = graphicsManager.FindProperty("m_InstancingStripping");
+        instancingStripping.enumValueIndex = 2;
+
+        SerializedProperty lightmapKeepPlain = graphicsManager.FindProperty("m_LightmapKeepPlain");
+        lightmapKeepPlain.boolValue = true;
+
+        SerializedProperty lightmapKeepDirCombined = graphicsManager.FindProperty("m_LightmapKeepDirCombined");
+        lightmapKeepDirCombined.boolValue = true;
+
+        SerializedProperty lightmapKeepDynamicPlain = graphicsManager.FindProperty("m_LightmapKeepDynamicPlain");
+        lightmapKeepDynamicPlain.boolValue = true;
+
+        SerializedProperty lightmapKeepDynamicDirCombined = graphicsManager.FindProperty("m_LightmapKeepDynamicDirCombined");
+        lightmapKeepDynamicDirCombined.boolValue = true;
+
+        SerializedProperty lightmapKeepShadowMask = graphicsManager.FindProperty("m_LightmapKeepShadowMask");
+        lightmapKeepShadowMask.boolValue = true;
+
+        SerializedProperty lightmapKeepSubtractive = graphicsManager.FindProperty("m_LightmapKeepSubtractive");
+        lightmapKeepSubtractive.boolValue = true;
+#endif
+
+        SerializedProperty albedoSwatchInfos = graphicsManager.FindProperty("m_AlbedoSwatchInfos");
+        albedoSwatchInfos.ClearArray();
+        albedoSwatchInfos.arraySize = 0;
+
+        SerializedProperty lightsUseLinearIntensity = graphicsManager.FindProperty("m_LightsUseLinearIntensity");
+        lightsUseLinearIntensity.boolValue = true;
+
+        SerializedProperty lightsUseColorTemperature = graphicsManager.FindProperty("m_LightsUseColorTemperature");
+        lightsUseColorTemperature.boolValue = true;
+
+        graphicsManager.ApplyModifiedProperties();
+    }
+
+    public static FogSettings GetFogSettings()
+    {
+        VRC.Core.Logger.Log("Force-enabling Fog", VRC.Core.DebugLevel.All);
+
+        const string graphicsSettingsAssetPath = "ProjectSettings/GraphicsSettings.asset";
+        SerializedObject graphicsManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath(graphicsSettingsAssetPath)[0]);
+
+
+        SerializedProperty fogStrippingSerializedProperty = graphicsManager.FindProperty("m_FogStripping");
+        FogSettings.FogStrippingMode fogStripping = (FogSettings.FogStrippingMode)fogStrippingSerializedProperty.enumValueIndex;
+
+        SerializedProperty fogKeepLinearSerializedProperty = graphicsManager.FindProperty("m_FogKeepLinear");
+        bool keepLinear = fogKeepLinearSerializedProperty.boolValue;
+
+        SerializedProperty fogKeepExpSerializedProperty = graphicsManager.FindProperty("m_FogKeepExp");
+        bool keepExp = fogKeepExpSerializedProperty.boolValue;
+
+        SerializedProperty fogKeepExp2SerializedProperty = graphicsManager.FindProperty("m_FogKeepExp2");
+        bool keepExp2 = fogKeepExp2SerializedProperty.boolValue;
+
+        FogSettings fogSettings = new FogSettings(fogStripping, keepLinear, keepExp, keepExp2);
+        return fogSettings;
+    }
+
+    public static void SetFogSettings(FogSettings fogSettings)
+    {
+        VRC.Core.Logger.Log("Force-enabling Fog", VRC.Core.DebugLevel.All);
+
+        const string graphicsSettingsAssetPath = "ProjectSettings/GraphicsSettings.asset";
+        SerializedObject graphicsManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath(graphicsSettingsAssetPath)[0]);
+
+        SerializedProperty fogStripping = graphicsManager.FindProperty("m_FogStripping");
+        fogStripping.enumValueIndex = (int)fogSettings.fogStrippingMode;
+
+        SerializedProperty fogKeepLinear = graphicsManager.FindProperty("m_FogKeepLinear");
+        fogKeepLinear.boolValue = fogSettings.keepLinear;
+
+        SerializedProperty fogKeepExp = graphicsManager.FindProperty("m_FogKeepExp");
+        fogKeepExp.boolValue = fogSettings.keepExp;
+
+        SerializedProperty fogKeepExp2 = graphicsManager.FindProperty("m_FogKeepExp2");
+        fogKeepExp2.boolValue = fogSettings.keepExp2;
+
+        graphicsManager.ApplyModifiedProperties();
+    }
+
+    static void SetAudioSettings()
+    {
+        var config = AudioSettings.GetConfiguration();
+        config.dspBufferSize = 0; // use default
+        config.speakerMode = AudioSpeakerMode.Stereo; // use default
+        config.sampleRate = 48000; // forcing 48k seems to avoid sample rate conversion problems
+        if (EditorUserBuildSettings.selectedBuildTargetGroup == BuildTargetGroup.Android)
+        {
+            config.numRealVoices = 24;
+            config.numVirtualVoices = 32;
+        }
+        else
+        {
+            config.numRealVoices = 32;
+            config.numVirtualVoices = 64;
+        }
+        AudioSettings.Reset(config);
+    }
+
+    static void SetPlayerSettings()
+    {
+        // asset bundles MUST be built with settings that are compatible with VRC client
+        #if VRC_OVERRIDE_COLORSPACE_GAMMA
+        PlayerSettings.colorSpace = ColorSpace.Gamma;
+        #else
+        PlayerSettings.colorSpace = ColorSpace.Linear;
+        #endif
+
+        #if !VRC_CLIENT // In client rely on platform-switcher
+        PlayerSettings.SetVirtualRealitySupported(EditorUserBuildSettings.selectedBuildTargetGroup, true);
+        #endif
+
+        PlayerSettings.graphicsJobs = false; // else we get occasional crashing
+
+        PlayerSettings.gpuSkinning = true;
+
+        PlayerSettings.stereoRenderingPath = StereoRenderingPath.SinglePass;
+
+        #if UNITY_2018_4_OR_NEWER
+        PlayerSettings.scriptingRuntimeVersion = ScriptingRuntimeVersion.Latest;
+        #endif
+
+        #if VRC_VR_OCULUS_QUEST
+        PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
+        #elif VRC_VR_FOCUS
+        PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARMv7;
+        #endif
+
+        #if UNITY_ANDROID
+        if(PlayerSettings.Android.targetArchitectures.HasFlag(AndroidArchitecture.ARM64))
+        {
+            // Since we need different IL2CPP args we can't build ARM64 with other Architectures.
+            PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
+            PlayerSettings.SetAdditionalIl2CppArgs("");
+        }
+        else
+        {
+            PlayerSettings.SetAdditionalIl2CppArgs("--linker-flags=\"-long-plt\"");
+        }
+        #else
+        PlayerSettings.SetAdditionalIl2CppArgs("");
+        #endif
+
+        SetActiveSDKDefines();
+
+        EnableBatching(true);
+    }
+
+    public static void SetActiveSDKDefines()
+    {
+        bool definesChanged = false;
+        BuildTargetGroup buildTargetGroup = BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget);
+        List<string> defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup).Split(';').ToList();
+
+        Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+        if (assemblies.Any(assembly => assembly.GetType("VRC.Udon.UdonBehaviour") != null))
+        {
+            if (!defines.Contains("UDON", StringComparer.OrdinalIgnoreCase))
+            {
+                defines.Add("UDON");
+                definesChanged = true;
+            }
+        }
+        else if (defines.Contains("UDON"))
+            defines.Remove("UDON");
+
+        if (VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK2))
+        {
+            if (!defines.Contains("VRC_SDK_VRCSDK2", StringComparer.OrdinalIgnoreCase))
+            {
+                defines.Add("VRC_SDK_VRCSDK2");
+                definesChanged = true;
+            }
+        }
+        else if (defines.Contains("VRC_SDK_VRCSDK2"))
+            defines.Remove("VRC_SDK_VRCSDK2");
+
+        if (VRCSdk3Analysis.IsSdkDllActive(VRCSdk3Analysis.SdkVersion.VRCSDK3))
+        {
+            if (!defines.Contains("VRC_SDK_VRCSDK3", StringComparer.OrdinalIgnoreCase))
+            {
+                defines.Add("VRC_SDK_VRCSDK3");
+                definesChanged = true;
+            }
+        }
+        else if (defines.Contains("VRC_SDK_VRCSDK3"))
+            defines.Remove("VRC_SDK_VRCSDK3");
+
+        if (definesChanged)
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, string.Join(";", defines.ToArray()));
+    }
+
+    static void SetBuildTarget()
+    {
+#if !VRC_CLIENT
+        VRC.Core.Logger.Log("Setting build target", VRC.Core.DebugLevel.All);
+
+        BuildTarget target = UnityEditor.EditorUserBuildSettings.activeBuildTarget;
+
+        if (!allowedBuildtargets.Contains(target))
+        {
+            Debug.LogError("Target not supported, switching to one that is.");
+            target = allowedBuildtargets[0];
+#pragma warning disable CS0618 // Type or member is obsolete
+            EditorUserBuildSettings.SwitchActiveBuildTarget(target);
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+#endif
+    }
+
+    private static void LoadEditorResources()
+    {
+        AvatarPerformanceStats.Initialize();
+    }
+
+    public struct FogSettings
+    {
+        public enum FogStrippingMode
+        {
+            Automatic,
+            Custom
+        }
+
+        public readonly FogStrippingMode fogStrippingMode;
+        public readonly bool keepLinear;
+        public readonly bool keepExp;
+        public readonly bool keepExp2;
+
+        public FogSettings(FogStrippingMode fogStrippingMode)
+        {
+            this.fogStrippingMode = fogStrippingMode;
+            keepLinear = true;
+            keepExp = true;
+            keepExp2 = true;
+        }
+
+        public FogSettings(FogStrippingMode fogStrippingMode, bool keepLinear, bool keepExp, bool keepExp2)
+        {
+            this.fogStrippingMode = fogStrippingMode;
+            this.keepLinear = keepLinear;
+            this.keepExp = keepExp;
+            this.keepExp2 = keepExp2;
+        }
+    }
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/EnvConfig.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 10d9f721d76e07a47bc9e5f61e2fae72
+timeCreated: 1455115256
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/HDRColorFixerUtility.cs

@@ -0,0 +1,73 @@
+using UnityEditor;
+using UnityEngine;
+
+public static class HDRColorFixerUtility
+{
+    [MenuItem("VRChat SDK/Utilities/Convert HDR Material Colors/To Linear", false, 995)]
+    private static void ConvertToLinear()
+    {
+        if (!TryConvert())
+            EditorUtility.DisplayDialog("Error", "Please select one or more HDR materials to convert.", "OK");
+    }
+
+    [MenuItem("VRChat SDK/Utilities/Convert HDR Material Colors/To Gamma", false, 996)]
+    private static void ConvertToGamma()
+    {
+        if (!TryConvert(false))
+            EditorUtility.DisplayDialog("Error", "Please select one or more HDR materials to convert.", "OK");
+    }
+
+    static bool TryConvert(bool toLinear = true)
+    {
+        Object[] selection = Selection.objects;
+        if (selection == null)
+            return false;
+
+        int matCount = 0;
+        int colorCount = 0;
+        foreach (Material mat in selection)
+        {
+            matCount++;
+            MaterialProperty[] props = MaterialEditor.GetMaterialProperties(new Material[] { mat });
+            if ((props == null) || (props.Length == 0))
+                return false;
+
+            foreach (MaterialProperty m in props)
+            {
+                if (m.flags == MaterialProperty.PropFlags.HDR)
+                {
+                    //Color prev = m.colorValue;
+                    m.colorValue = (toLinear ? m.colorValue.linear : m.colorValue.gamma);
+                    colorCount++;
+                    //Debug.Log("prev: " + prev + ", current: " + m.colorValue);
+                }
+            }
+        }
+
+        if (colorCount == 0)
+            EditorUtility.DisplayDialog("Result", "Found no HDR Color properties in the selected material" + (matCount > 1 ? "s." : "."), "OK");
+        else
+            EditorUtility.DisplayDialog("Result", "Converted " + colorCount + " HDR Color propert"+ (colorCount > 1 ? "ies" : "y") + " in "+matCount+" material"+(matCount > 1 ? "s":"") + " to " + (toLinear ? "Linear" : "Gamma") + " color space.", "OK");
+
+        return true;
+    }
+    
+    [MenuItem("VRChat SDK/Utilities/Convert HDR Material Colors/To Linear", true, 995)]
+    [MenuItem("VRChat SDK/Utilities/Convert HDR Material Colors/To Gamma", true, 996)]
+    private static bool CheckSelection()
+    {
+        if (Selection.objects.Length == 0)
+            return false;
+        bool allMaterials = true;
+        foreach (Object obj in Selection.objects)
+        {
+            if (obj.GetType() != typeof(Material))
+            {
+                allMaterials = false;
+                break;
+            }
+        }
+        return allMaterials;
+    }
+
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/HDRColorFixerUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c3399613f583f3e46b2df27ae87dd5d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/SDK3Compatibility.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 57304ced9b2de5f48a30b7b662d18c19
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/SDK3Compatibility/VRCSdk3Analysis.cs

@@ -0,0 +1,120 @@
+using System.Reflection;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+using System.Linq;
+using UnityEditor;
+
+public class VRCSdk3Analysis
+{
+    static Assembly GetAssemblyByName(string name)
+    {
+        return AppDomain.CurrentDomain.GetAssemblies().
+               SingleOrDefault(assembly => assembly.GetName().Name == name);
+    }
+
+    static List<Component> GetSceneComponentsFromAssembly( Assembly assembly )
+    {
+        if (assembly == null)
+            return new List<Component>();
+
+        Type[] types = assembly.GetTypes();
+
+        List<Component> present = new List<Component>();
+        foreach (var type in types )
+        {
+            if (!type.IsSubclassOf(typeof(MonoBehaviour)))
+                continue;
+
+            var monos = VRC.Tools.FindSceneObjectsOfTypeAll(type);
+            present.AddRange(monos);
+        }
+        return present;
+    }
+
+    public enum SdkVersion
+    {
+        VRCSDK2,
+        VRCSDK3
+    };
+
+    public static List<Component> GetSDKInScene(SdkVersion version)
+    {
+        var assembly = GetAssemblyByName( version.ToString() );
+        return GetSceneComponentsFromAssembly(assembly);
+    }
+
+    public static bool IsSdkDllActive(SdkVersion version)
+    {
+        string assembly = version.ToString();
+        PluginImporter importer = AssetImporter.GetAtPath("Assets/VRCSDK/Plugins/" + assembly + ".dll") as PluginImporter;
+        if (importer == false)
+        {
+            //Handle Avatar Dll Split
+            importer = AssetImporter.GetAtPath("Assets/VRCSDK/Plugins/" + assembly + "A.dll") as PluginImporter;
+            if (importer == false)
+                return false;
+        }
+
+        return importer.GetCompatibleWithAnyPlatform();
+    }
+
+    //public static void SetSdkVersionActive(SdkVersion version)
+    //{
+    //    AssetDatabase.StartAssetEditing();
+
+    //    PluginImporter importer = AssetImporter.GetAtPath("Assets/VRCSDK/Plugins/" + version + ".dll") as PluginImporter;
+    //    if (importer == null)
+    //        return;
+
+    //    SetSDKDefine(version);
+
+    //    var other = SdkVersion.VRCSDK2;
+    //    if (version == SdkVersion.VRCSDK2)
+    //        other = SdkVersion.VRCSDK3;
+
+    //    SetSDKAssembly(other, false);
+    //    SetSDKAssembly(version, true);
+
+    //    AssetDatabase.StopAssetEditing();
+    //}
+
+    //static void SetSDKAssembly( SdkVersion version, bool active )
+    //{
+    //    string assembly = version.ToString();
+    //    PluginImporter importer = AssetImporter.GetAtPath("Assets/VRCSDK/Plugins/" + assembly + ".dll") as PluginImporter;
+    //    if (importer)
+    //    {
+    //        importer.SetCompatibleWithAnyPlatform(active);
+    //        importer.SetCompatibleWithEditor(active);
+    //        importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, active);
+    //        importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, active);
+    //        importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, active);
+    //        importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, active);
+    //        importer.SetCompatibleWithPlatform(BuildTarget.Android, active);
+    //        importer.SaveAndReimport();
+    //    }
+    //}
+
+    //static void SetSDKDefine( SdkVersion version )
+    //{
+    //    string defineString = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Standalone);
+    //    var defs = defineString.Split(';');
+    //    string finalDefs = null;
+    //    foreach( var s in defs )
+    //    {
+    //        if (s != "VRC_SDK_VRCSDK2" && s != "VRC_SDK_VRCSDK3")
+    //        {
+    //            if (finalDefs == null)
+    //                finalDefs = s;
+    //            else
+    //                finalDefs += ";" + s;
+    //        }
+    //    }
+    //    if (version == SdkVersion.VRCSDK2)
+    //        finalDefs += ";VRC_SDK_VRCSDK2";
+    //    else if (version == SdkVersion.VRCSDK3)
+    //        finalDefs += ";VRC_SDK_VRCSDK3";
+    //    PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Standalone, finalDefs);
+    //}
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/SDK3Compatibility/VRCSdk3Analysis.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 93710d221addc0243ba90dd20369844b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/VRCSDK/Dependencies/VRChat/Editor/SDKUpdater.cs

@@ -0,0 +1,70 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+
+public class SDKUpdater : MonoBehaviour
+{
+	static string GetCurrentVersion()
+	{
+		string currentVersion = "";
+		string versionTextPath = Application.dataPath + "/VRCSDK/version.txt";
+		if(System.IO.File.Exists(versionTextPath))
+		{
+			string[] versionFileLines = System.IO.File.ReadAllLines(versionTextPath);
+			if(versionFileLines.Length > 0)
+				currentVersion = versionFileLines[0];	
+		}
+		return currentVersion;
+	}
+
+	[MenuItem("VRChat SDK/Utilities/Check For Updates")]
+	static void CheckForUpdatesWithProgressBar()
+	{
+		CheckForUpdates(false);
+	}
+
+	public static void CheckForUpdates(bool isSilent = true)
+	{
+		Debug.Log("Checking for VRChat SDK updates...");
+		if(!isSilent)
+			EditorUtility.DisplayProgressBar("SDK Updater", "Checking for updates...", 1f);
+		
+		VRC.Core.ConfigManager.RemoteConfig.Init(delegate() {
+			string currentSdkVersion = GetCurrentVersion();
+			string sdkVersion = VRC.Core.ConfigManager.RemoteConfig.GetString("devSdkVersion");
+			string sdkUrl = VRC.Core.ConfigManager.RemoteConfig.GetString("devSdkUrl");
+			EditorUtility.ClearProgressBar();
+
+			if(sdkVersion == currentSdkVersion)
+			{
+				ShowDownloadUpdatePopup(false, currentSdkVersion, sdkUrl, isSilent);
+			}
+			else
+			{
+				ShowDownloadUpdatePopup(true, sdkVersion, sdkUrl, isSilent);
+			}
+		});
+	}
+
+	static void ShowDownloadUpdatePopup(bool updateAvailable, string latestVersion, string sdkUrl, bool isSilent)
+	{
+		if(!updateAvailable)
+		{
+			if(!isSilent)
+				EditorUtility.DisplayDialog("VRChat SDK Updater", "SDK is up to date (version " + latestVersion + ")", "Okay");
+		}
+		else
+		{
+			if(EditorUtility.DisplayDialog("VRChat SDK Updater", "An update is available (version " + latestVersion + ")", "Download", "Cancel"))
+			{
+				DownloadUpdate(sdkUrl);
+			}
+		}
+	}
+
+	static void DownloadUpdate(string sdkUrl)
+	{
+		Application.OpenURL(sdkUrl);
+	}
+
+}

Assets/VRCSDK/Dependencies/VRChat/Editor/SDKUpdater.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7b8bb626428d0f341b9ed6a68cb5c9cc
+timeCreated: 1473273663
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: