init project

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/ApplicationDataPath.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+
+namespace Unity.PlasticSCM.Editor
+{
+    internal static class ApplicationDataPath
+    {
+        internal static string Get()
+        {
+            return mApplicationDataPath ?? Application.dataPath;
+        }
+
+        internal static void InitializeForTesting(string applicationDataPath)
+        {
+            mApplicationDataPath = applicationDataPath;
+        }
+
+        internal static void Reset()
+        {
+            mApplicationDataPath = null;
+        }
+
+        static string mApplicationDataPath;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/ApplicationDataPath.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.CollabProxy.Editor")]
+[assembly: InternalsVisibleTo("Unity.PlasticSCM.Editor.Entities")]
+[assembly: InternalsVisibleTo("Unity.PlasticSCM.EditorTests")]
+[assembly: InternalsVisibleTo("Unity.PlasticSCM.DevTools")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetCopyPathOperation.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+
+using UnityEditor;
+
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal class AssetCopyPathOperation : IAssetMenuCopyPathOperation
+    {
+        internal AssetCopyPathOperation(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            IAssetStatusCache assetStatusCache,
+            AssetUVCSOperations.IAssetSelection assetSelection)
+        {
+            mWkInfo = wkInfo;
+            mPlasticAPI = plasticApi;
+            mAssetStatusCache = assetStatusCache;
+            mAssetSelection = assetSelection;
+        }
+
+        void IAssetMenuCopyPathOperation.CopyFilePath(bool relativePath)
+        {
+            List<string> selectedPaths = GetSelectedPaths.ForOperation(
+                mWkInfo,
+                mAssetSelection.GetSelectedAssets(),
+                mPlasticAPI,
+                mAssetStatusCache,
+                AssetMenuOperations.CopyFilePath,
+                includeMetaFiles: false);
+
+            EditorGUIUtility.systemCopyBuffer = GetFilePathList.FromSelectedPaths(
+                selectedPaths,
+                relativePath,
+                mWkInfo.ClientPath);
+        }
+
+        readonly WorkspaceInfo mWkInfo;
+        readonly IPlasticAPI mPlasticAPI;
+        readonly IAssetStatusCache mAssetStatusCache;
+        readonly AssetUVCSOperations.IAssetSelection mAssetSelection;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetCopyPathOperation.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d2a9f8ad3405465db8e62d36f2686b68
+timeCreated: 1730989830

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetFilesFilterPatternsMenuBuilder.cs

@@ -0,0 +1,274 @@
+using Codice.Client.BaseCommands;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Items;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal interface IAssetFilesFilterPatternsMenuOperations
+    {
+        void AddFilesFilterPatterns(
+            FilterTypes type, FilterActions action, FilterOperationType operation);
+    }
+
+    internal class AssetFilesFilterPatternsMenuBuilder
+    {
+        internal string IgnoredSubmenuItem { get { return mIgnoredSubmenuItem; } }
+        internal string HiddenChangesSubmenuItem { get { return mHiddenChangesSubmenuItem; } }
+        
+        internal AssetFilesFilterPatternsMenuBuilder(
+            int ignoredMenuItemsPriority,
+            int hiddenChangesMenuItemsPriority)
+        {
+            mIgnoredMenuItemsPriority = ignoredMenuItemsPriority;
+            mHiddenChangesMenuItemsPriority = hiddenChangesMenuItemsPriority;
+
+            mIgnoredSubmenuItem = string.Format(
+                "{0}/{1}",
+                PlasticLocalization.GetString(PlasticLocalization.Name.PrefixUnityVersionControlMenu),
+                PlasticLocalization.GetString(PlasticLocalization.Name.MenuAddToIgnoreList));
+
+            mHiddenChangesSubmenuItem = string.Format(
+                "{0}/{1}",
+                PlasticLocalization.GetString(PlasticLocalization.Name.PrefixUnityVersionControlMenu),
+                PlasticLocalization.GetString(PlasticLocalization.Name.MenuAddToHiddenChangesList));
+        }
+
+        internal void SetOperations(
+            IAssetFilesFilterPatternsMenuOperations operations)
+        {
+            mOperations = operations;
+        }
+
+        internal void UpdateMenuItems(FilterMenuActions actions)
+        {
+            UpdateIgnoredMenuItems(actions);
+            UpdateHiddenChangesMenuItems(actions);
+
+            HandleMenuItem.UpdateAllMenus();
+        }
+
+        internal void RemoveMenuItems()
+        {
+            RemoveIgnoredMenuItems();
+            RemoveHiddenChangesMenuItems();
+        }
+
+        internal void IgnoredByName_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.Ignored, FilterActions.ByName,
+                GetIgnoredFilterOperationType());
+        }
+
+        internal void IgnoredByExtension_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.Ignored, FilterActions.ByExtension,
+                GetIgnoredFilterOperationType());
+        }
+
+        internal void IgnoredByFullPath_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.Ignored, FilterActions.ByFullPath,
+                GetIgnoredFilterOperationType());
+        }
+
+        internal void HiddenChangesByName_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.HiddenChanges, FilterActions.ByName,
+                GetHiddenChangesFilterOperationType());
+        }
+
+        internal void HiddenChangesByExtension_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.HiddenChanges, FilterActions.ByExtension,
+                GetHiddenChangesFilterOperationType());
+        }
+
+        internal void HiddenChangesByFullPath_Click()
+        {
+            if (mOperations == null)
+                ShowWindow.UVCS();
+
+            mOperations.AddFilesFilterPatterns(
+                FilterTypes.HiddenChanges, FilterActions.ByFullPath,
+                GetHiddenChangesFilterOperationType());
+        }
+
+        void UpdateIgnoredMenuItems(FilterMenuActions actions)
+        {
+            RemoveIgnoredMenuItems();
+
+            mIgnoredSubmenuItem = string.Format(
+                "{0}/{1}",
+                PlasticLocalization.Name.PrefixUnityVersionControlMenu.GetString(),
+                actions.IgnoredTitle);
+            
+            if (!actions.Operations.HasFlag(FilterMenuOperations.Ignore))
+            {
+                HandleMenuItem.AddMenuItem(
+                    mIgnoredSubmenuItem,
+                    mIgnoredMenuItemsPriority,
+                    DisabledMenuItem_Click, ValidateDisabledMenuItem);
+                return;
+            }
+
+            mIgnoredByNameMenuItem = GetIgnoredMenuItemName(actions.FilterByName);
+            mIgnoredByExtensionMenuItem = GetIgnoredMenuItemName(actions.FilterByExtension);
+            mIgnoredByFullPathMenuItem = GetIgnoredMenuItemName(actions.FilterByFullPath);
+
+            HandleMenuItem.AddMenuItem(
+                mIgnoredByNameMenuItem,
+                mIgnoredMenuItemsPriority,
+                IgnoredByName_Click, ValidateEnabledMenuItem);
+
+            if (actions.Operations.HasFlag(FilterMenuOperations.IgnoreByExtension))
+                HandleMenuItem.AddMenuItem(
+                    mIgnoredByExtensionMenuItem,
+                    mIgnoredMenuItemsPriority,
+                    IgnoredByExtension_Click, ValidateEnabledMenuItem);
+
+            HandleMenuItem.AddMenuItem(
+                mIgnoredByFullPathMenuItem,
+                mIgnoredMenuItemsPriority,
+                IgnoredByFullPath_Click, ValidateEnabledMenuItem);
+        }
+
+        void UpdateHiddenChangesMenuItems(FilterMenuActions actions)
+        {
+            RemoveHiddenChangesMenuItems();
+
+            mHiddenChangesSubmenuItem = string.Format(
+                "{0}/{1}",
+                PlasticLocalization.Name.PrefixUnityVersionControlMenu.GetString(),
+                actions.HiddenChangesTitle);
+
+            if (!actions.Operations.HasFlag(FilterMenuOperations.HideChanged))
+            {
+                HandleMenuItem.AddMenuItem(
+                    mHiddenChangesSubmenuItem,
+                    mHiddenChangesMenuItemsPriority,
+                    DisabledMenuItem_Click, ValidateDisabledMenuItem);
+                return;
+            }
+
+            mHiddenChangesByNameMenuItem = GetHiddenChangesMenuItemName(actions.FilterByName);
+            mHiddenChangesByExtensionMenuItem = GetHiddenChangesMenuItemName(actions.FilterByExtension);
+            mHiddenChangesByFullPathMenuItem = GetHiddenChangesMenuItemName(actions.FilterByFullPath);
+
+            HandleMenuItem.AddMenuItem(
+                mHiddenChangesByNameMenuItem,
+                mIgnoredMenuItemsPriority,
+                HiddenChangesByName_Click, ValidateEnabledMenuItem);
+
+            if (actions.Operations.HasFlag(FilterMenuOperations.HideChangedByExtension))
+                HandleMenuItem.AddMenuItem(
+                    mHiddenChangesByExtensionMenuItem,
+                    mIgnoredMenuItemsPriority,
+                    HiddenChangesByExtension_Click, ValidateEnabledMenuItem);
+
+            HandleMenuItem.AddMenuItem(
+                mHiddenChangesByFullPathMenuItem,
+                mIgnoredMenuItemsPriority,
+                HiddenChangesByFullPath_Click, ValidateEnabledMenuItem);
+        }
+
+        void RemoveIgnoredMenuItems()
+        {
+            HandleMenuItem.RemoveMenuItem(mIgnoredSubmenuItem);
+            HandleMenuItem.RemoveMenuItem(mIgnoredByNameMenuItem);
+            HandleMenuItem.RemoveMenuItem(mIgnoredByExtensionMenuItem);
+            HandleMenuItem.RemoveMenuItem(mIgnoredByFullPathMenuItem);
+        }
+
+        void RemoveHiddenChangesMenuItems()
+        {
+            HandleMenuItem.RemoveMenuItem(mHiddenChangesSubmenuItem);
+            HandleMenuItem.RemoveMenuItem(mHiddenChangesByNameMenuItem);
+            HandleMenuItem.RemoveMenuItem(mHiddenChangesByExtensionMenuItem);
+            HandleMenuItem.RemoveMenuItem(mHiddenChangesByFullPathMenuItem);
+        }
+
+        FilterOperationType GetIgnoredFilterOperationType()
+        {
+            return GetFilterOperationType(
+                mIgnoredByNameMenuItem,
+                PlasticLocalization.Name.MenuAddToIgnoreList);
+        }
+
+        FilterOperationType GetHiddenChangesFilterOperationType()
+        {
+            return GetFilterOperationType(
+                mHiddenChangesByNameMenuItem,
+                PlasticLocalization.Name.MenuAddToHiddenChangesList);
+        }
+        
+        static FilterOperationType GetFilterOperationType(string menuItemName, PlasticLocalization.Name expectedTitle)
+        {
+            string[] split = menuItemName.Split('/');
+            if (split.Length < 2)
+                return FilterOperationType.Remove;
+            
+            string parentMenu = split[split.Length - 2];
+            return parentMenu.StartsWith(expectedTitle.GetString())
+                ? FilterOperationType.Add
+                : FilterOperationType.Remove;
+        }
+
+        void DisabledMenuItem_Click() { }
+
+        bool ValidateEnabledMenuItem() { return true; }
+
+        bool ValidateDisabledMenuItem() { return false; }
+
+        string GetIgnoredMenuItemName(string filterPattern)
+        {
+            return UnityMenuItem.GetText(
+                mIgnoredSubmenuItem,
+                UnityMenuItem.EscapedText(filterPattern));
+        }
+
+        string GetHiddenChangesMenuItemName(string filterPattern)
+        {
+            return UnityMenuItem.GetText(
+                mHiddenChangesSubmenuItem,
+                UnityMenuItem.EscapedText(filterPattern));
+        }
+
+        IAssetFilesFilterPatternsMenuOperations mOperations;
+
+        string mIgnoredSubmenuItem;
+        string mHiddenChangesSubmenuItem;
+
+        string mIgnoredByNameMenuItem;
+        string mHiddenChangesByNameMenuItem;
+
+        string mIgnoredByExtensionMenuItem;
+        string mHiddenChangesByExtensionMenuItem;
+
+        string mIgnoredByFullPathMenuItem;
+        string mHiddenChangesByFullPathMenuItem;
+
+        readonly int mIgnoredMenuItemsPriority;
+        readonly int mHiddenChangesMenuItemsPriority;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetFilesFilterPatternsMenuBuilder.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetMenuOperations.cs

@@ -0,0 +1,301 @@
+using System;
+
+using UnityEditor.VersionControl;
+
+using Codice;
+using Codice.Client.Commands.Tree;
+using Codice.Client.Commands.WkTree;
+using Codice.CM.Common;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetsOverlays;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    [Flags]
+    internal enum AssetMenuOperations : byte
+    {
+        None =                   0,
+        Checkout =               1 << 0,
+        Diff =                   1 << 1,
+        History =                1 << 2,
+        Add =                    1 << 3,
+        Checkin =                1 << 4,
+        Undo =                   1 << 5,
+        CopyFilePath =           1 << 6
+    }
+
+    internal class SelectedAssetGroupInfo
+    {
+        internal int SelectedCount;
+
+        internal bool IsControlledSelection;
+        internal bool IsCheckedInSelection;
+        internal bool IsCheckedOutSelection;
+        internal bool IsChangedSelection;
+        internal bool IsPrivateSelection;
+        internal bool IsAddedSelection;
+        internal bool IsFileSelection;
+        internal bool IsMovedSelection;
+        internal bool HasAnyAddedInSelection;
+        internal bool HasAnyRemoteLockedInSelection;
+
+        internal static SelectedAssetGroupInfo BuildFromAssetList(
+            WorkspaceInfo wkInfo,
+            AssetList assetList,
+            IPlasticAPI plasticApi,
+            IAssetStatusCache statusCache)
+        {
+            bool isCheckedInSelection = true;
+            bool isControlledSelection = true;
+            bool isCheckedOutSelection = true;
+            bool isChangedSelection = true;
+            bool isPrivateSelection = true;
+            bool isAddedSelection = true;
+            bool isFileSelection = true;
+            bool isMovedSelection = true;
+            bool hasAnyAddedInSelection = false;
+            bool hasAnyRemoteLockedInSelection = false;
+
+            int selectedCount = 0;
+
+            foreach (Asset asset in assetList)
+            {
+                string fullPath = AssetsPath.GetFullPathUnderWorkspace.
+                    ForAsset(wkInfo.ClientPath, asset.path);
+
+                if (fullPath == null)
+                    continue;
+
+                SelectedAssetGroupInfo singleFileGroupInfo = BuildFromSingleFile(
+                    fullPath, asset.isFolder, wkInfo, plasticApi, statusCache);
+
+                if (!singleFileGroupInfo.IsCheckedInSelection)
+                    isCheckedInSelection = false;
+
+                if (!singleFileGroupInfo.IsControlledSelection)
+                    isControlledSelection = false;
+
+                if (!singleFileGroupInfo.IsCheckedOutSelection)
+                    isCheckedOutSelection = false;
+
+                if (!singleFileGroupInfo.IsChangedSelection)
+                    isChangedSelection = false;
+
+                if (!singleFileGroupInfo.IsPrivateSelection)
+                    isPrivateSelection = false;
+
+                if (!singleFileGroupInfo.IsAddedSelection)
+                    isAddedSelection = false;
+
+                if (!singleFileGroupInfo.IsFileSelection)
+                    isFileSelection = false;
+
+                if (!singleFileGroupInfo.IsMovedSelection)
+                    isMovedSelection = false;
+
+                if (singleFileGroupInfo.HasAnyAddedInSelection)
+                    hasAnyAddedInSelection = true;
+
+                if (singleFileGroupInfo.HasAnyRemoteLockedInSelection)
+                    hasAnyRemoteLockedInSelection = true;
+
+                selectedCount++;
+            }
+
+            return new SelectedAssetGroupInfo()
+            {
+                IsCheckedInSelection = isCheckedInSelection,
+                IsCheckedOutSelection = isCheckedOutSelection,
+                IsChangedSelection = isChangedSelection,
+                IsControlledSelection = isControlledSelection,
+                IsPrivateSelection = isPrivateSelection,
+                IsAddedSelection = isAddedSelection,
+                IsFileSelection = isFileSelection,
+                IsMovedSelection = isMovedSelection,
+                HasAnyAddedInSelection = hasAnyAddedInSelection,
+                HasAnyRemoteLockedInSelection = hasAnyRemoteLockedInSelection,
+                SelectedCount = selectedCount,
+            };
+        }
+
+        internal static SelectedAssetGroupInfo BuildFromSingleFile(
+            string fullPath,
+            bool isDirectory,
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            IAssetStatusCache statusCache)
+        {
+            bool isCheckedInSelection = true;
+            bool isControlledSelection = true;
+            bool isCheckedOutSelection = true;
+            bool isChangedSelection = false;
+            bool isPrivateSelection = true;
+            bool isAddedSelection = true;
+            bool isFileSelection = true;
+            bool isMovedSelection = false;
+            bool hasAnyAddedInSelection = false;
+            bool hasAnyRemoteLockedInSelection = false;
+
+            WorkspaceTreeNode wkTreeNode = plasticApi.
+                GetWorkspaceTreeNode(wkInfo, fullPath);
+
+            if (isDirectory)
+                isFileSelection = false;
+
+            if (CheckWorkspaceTreeNodeStatus.IsPrivate(wkTreeNode))
+                isControlledSelection = false;
+            else
+                isPrivateSelection = false;
+
+            if (CheckWorkspaceTreeNodeStatus.IsCheckedOut(wkTreeNode))
+                isCheckedInSelection = false;
+            else
+                isCheckedOutSelection = false;
+
+            if (CheckWorkspaceTreeNodeStatus.IsAdded(wkTreeNode))
+                hasAnyAddedInSelection = true;
+            else
+                isAddedSelection = false;
+
+            if (wkTreeNode != null)
+            {
+                TreeChangedNode treeChangedNode = plasticApi.
+                    GetChangedNodeForPath(wkInfo, fullPath);
+
+                if (treeChangedNode != null)
+                    isMovedSelection = treeChangedNode.MovedDst;
+            }
+
+            AssetStatus assetStatus = statusCache.GetStatus(fullPath);
+
+            if (ClassifyAssetStatus.IsLockedRemote(assetStatus))
+                hasAnyRemoteLockedInSelection = true;
+
+            if (ClassifyAssetStatus.IsChanged(assetStatus))
+                isChangedSelection = true;
+
+            return new SelectedAssetGroupInfo()
+            {
+                IsCheckedInSelection = isCheckedInSelection,
+                IsCheckedOutSelection = isCheckedOutSelection,
+                IsChangedSelection = isChangedSelection,
+                IsControlledSelection = isControlledSelection,
+                IsPrivateSelection = isPrivateSelection,
+                IsAddedSelection = isAddedSelection,
+                IsFileSelection = isFileSelection,
+                IsMovedSelection = isMovedSelection,
+                HasAnyAddedInSelection = hasAnyAddedInSelection,
+                HasAnyRemoteLockedInSelection = hasAnyRemoteLockedInSelection,
+                SelectedCount = 1,
+            };
+        }
+    }
+
+    internal interface IAssetMenuUVCSOperations
+    {
+        void ShowPendingChanges();
+        void Add();
+        void Checkout();
+        void Checkin();
+        void Undo();
+        void ShowDiff();
+        void ShowHistory();
+    }
+
+    internal interface IAssetMenuCopyPathOperation
+    {
+        void CopyFilePath(bool relativePath);
+    }
+
+    internal static class AssetMenuUpdater
+    {
+        internal static AssetMenuOperations GetAvailableMenuOperations(
+            SelectedAssetGroupInfo info)
+        {
+            AssetMenuOperations result = AssetMenuOperations.None;
+
+            if (info.SelectedCount == 0)
+            {
+                return result;
+            }
+
+            result |= AssetMenuOperations.CopyFilePath;
+
+            if (info.IsControlledSelection &&
+                info.IsCheckedInSelection &&
+                info.IsFileSelection &&
+                !info.HasAnyRemoteLockedInSelection)
+            {
+                result |= AssetMenuOperations.Checkout;
+            }
+
+            if (info.IsFileSelection &&
+                info.IsPrivateSelection)
+            {
+                result |= AssetMenuOperations.Add;
+            }
+
+            if (info.IsFileSelection &&
+                (info.IsPrivateSelection ||
+                 (info.IsControlledSelection &&
+                  (info.IsCheckedOutSelection ||
+                   info.IsChangedSelection))))
+            {
+                result |= AssetMenuOperations.Checkin;
+            }
+
+            if ((info.IsControlledSelection &&
+                 info.IsMovedSelection) ||
+                (info.IsFileSelection &&
+                info.IsControlledSelection &&
+                (info.IsCheckedOutSelection ||
+                info.IsChangedSelection)))
+            {
+                result |= AssetMenuOperations.Undo;
+            }
+
+            if (info.SelectedCount == 1 &&
+                info.IsControlledSelection &&
+                !info.HasAnyAddedInSelection &&
+                info.IsFileSelection)
+            {
+                result |= AssetMenuOperations.Diff;
+            }
+
+            if (info.SelectedCount == 1 &&
+                info.IsControlledSelection &&
+                !info.HasAnyAddedInSelection)
+            {
+                result |= AssetMenuOperations.History;
+            }
+
+            return result;
+        }
+
+        internal static bool ShouldMenuOperationBeEnabled(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticAPI,
+            AssetUVCSOperations.IAssetSelection assetSelection,
+            IAssetStatusCache statusCache,
+            AssetMenuOperations operation)
+        {
+            AssetList assetList = assetSelection.GetSelectedAssets();
+
+            if (assetList.Count == 0)
+                return false;
+
+            SelectedAssetGroupInfo selectedGroupInfo = SelectedAssetGroupInfo.
+                BuildFromAssetList(wkInfo, assetList, plasticAPI, statusCache);
+
+            if (assetList.Count != selectedGroupInfo.SelectedCount)
+                return false;
+
+            AssetMenuOperations operations = AssetMenuUpdater.
+                GetAvailableMenuOperations(selectedGroupInfo);
+
+            return operations.HasFlag(operation);
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetMenuOperations.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetUVCSOperations.cs

@@ -0,0 +1,352 @@
+using System.IO;
+using System.Collections.Generic;
+
+using UnityEditor;
+using UnityEditor.VersionControl;
+
+using Codice.Client.BaseCommands;
+using Codice.Client.Commands;
+using Codice.Client.Commands.WkTree;
+using Codice.Client.Common;
+using Codice.Client.Common.Threading;
+using Codice.CM.Common;
+using GluonGui;
+using PlasticGui;
+using PlasticGui.Gluon;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.Diff;
+using PlasticGui.WorkspaceWindow.Items;
+using Unity.PlasticSCM.Editor.AssetMenu.Dialogs;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.AssetUtils.Processor;
+using Unity.PlasticSCM.Editor.Tool;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.Views.PendingChanges.Dialogs;
+
+using GluonIncomingChangesUpdater = PlasticGui.Gluon.WorkspaceWindow.IncomingChangesUpdater;
+using GluonCheckoutOperation = GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer.Operations.CheckoutOperation;
+using GluonUndoCheckoutOperation = GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer.Operations.UndoCheckoutOperation;
+using GluonAddoperation = GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer.Operations.AddOperation;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal class AssetUVCSOperations :
+        IAssetMenuUVCSOperations,
+        IAssetFilesFilterPatternsMenuOperations
+    {
+        internal interface IAssetSelection
+        {
+            AssetList GetSelectedAssets();
+        }
+
+        internal AssetUVCSOperations(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            ViewHost viewHost,
+            IWorkspaceWindow workspaceWindow,
+            IViewSwitcher viewSwitcher,
+            IGluonViewSwitcher gluonViewSwitcher,
+            IMergeViewLauncher mergeViewLauncher,
+            IHistoryViewLauncher historyViewLauncher,
+            IAssetStatusCache assetStatusCache,
+            IAssetSelection assetSelection,
+            ISaveAssets saveAssets,
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            WorkspaceOperationsMonitor workspaceOperationsMonitor,
+            PendingChangesUpdater pendingChangesUpdater,
+            IncomingChangesUpdater developerIncomingChangesUpdater,
+            GluonIncomingChangesUpdater gluonIncomingChangesUpdater,
+            ShelvedChangesUpdater shelvedChangesUpdater,
+            bool isGluonMode)
+        {
+            mWkInfo = wkInfo;
+            mPlasticAPI = plasticApi;
+            mViewHost = viewHost;
+            mWorkspaceWindow = workspaceWindow;
+            mViewSwitcher = viewSwitcher;
+            mGluonViewSwitcher = gluonViewSwitcher;
+            mMergeViewLauncher = mergeViewLauncher;
+            mHistoryViewLauncher = historyViewLauncher;
+            mAssetStatusCache = assetStatusCache;
+            mAssetSelection = assetSelection;
+            mSaveAssets = saveAssets;
+            mShowDownloadPlasticExeWindow = showDownloadPlasticExeWindow;
+            mWorkspaceOperationsMonitor = workspaceOperationsMonitor;
+            mPendingChangesUpdater = pendingChangesUpdater;
+            mDeveloperIncomingChangesUpdater = developerIncomingChangesUpdater;
+            mGluonIncomingChangesUpdater = gluonIncomingChangesUpdater;
+            mShelvedChangesUpdater = shelvedChangesUpdater;
+            mIsGluonMode = isGluonMode;
+
+            mGuiMessage = new UnityPlasticGuiMessage();
+            mProgressControls = new EditorProgressControls(
+                mGuiMessage, UnityConstants.UVCS_WINDOW_TITLE);
+        }
+
+        void IAssetMenuUVCSOperations.ShowPendingChanges()
+        {
+            mViewSwitcher.ShowPendingChanges();
+        }
+
+        void IAssetMenuUVCSOperations.Add()
+        {
+            List<string> selectedPaths = GetSelectedPaths.ForOperation(
+                mWkInfo,
+                mAssetSelection.GetSelectedAssets(),
+                mPlasticAPI,
+                mAssetStatusCache,
+                AssetMenuOperations.Add);
+
+            if (mIsGluonMode)
+            {
+                GluonAddoperation.Add(
+                    mWkInfo,
+                    mViewHost,
+                    mProgressControls,
+                    mGuiMessage,
+                    selectedPaths.ToArray(),
+                    false,
+                    mPendingChangesUpdater,
+                    mGluonIncomingChangesUpdater,
+                    () => RefreshAsset.VersionControlCache(mAssetStatusCache));
+                return;
+            }
+
+            AddOperation.Run(
+                mWkInfo,
+                mWorkspaceWindow,
+                mProgressControls,
+                null,
+                null,
+                selectedPaths,
+                false,
+                mPendingChangesUpdater,
+                mDeveloperIncomingChangesUpdater,
+                mShelvedChangesUpdater,
+                () => RefreshAsset.VersionControlCache(mAssetStatusCache));
+        }
+
+        void IAssetMenuUVCSOperations.Checkout()
+        {
+            List<string> selectedPaths = GetSelectedPaths.ForOperation(
+                mWkInfo,
+                mAssetSelection.GetSelectedAssets(),
+                mPlasticAPI,
+                mAssetStatusCache,
+                AssetMenuOperations.Checkout);
+
+            if (mIsGluonMode)
+            {
+                GluonCheckoutOperation.Checkout(
+                    mViewHost,
+                    mProgressControls,
+                    mGuiMessage,
+                    selectedPaths.ToArray(),
+                    false,
+                    mPendingChangesUpdater,
+                    mGluonIncomingChangesUpdater,
+                    () => RefreshAsset.VersionControlCache(mAssetStatusCache),
+                    mWkInfo);
+                return;
+            }
+
+            CheckoutOperation.Checkout(
+                mWorkspaceWindow,
+                null,
+                mProgressControls,
+                selectedPaths,
+                mPendingChangesUpdater,
+                mDeveloperIncomingChangesUpdater,
+                mShelvedChangesUpdater,
+                () => RefreshAsset.VersionControlCache(mAssetStatusCache),
+                mWkInfo);
+        }
+
+        void IAssetMenuUVCSOperations.Checkin()
+        {
+            List<string> selectedPaths = GetSelectedPaths.ForOperation(
+                mWkInfo,
+                mAssetSelection.GetSelectedAssets(),
+                mPlasticAPI,
+                mAssetStatusCache,
+                AssetMenuOperations.Checkin);
+
+            if (!CheckinDialog.CheckinPaths(
+                    mWkInfo,
+                    selectedPaths,
+                    mAssetStatusCache,
+                    mIsGluonMode,
+                    mWorkspaceWindow,
+                    mViewHost,
+                    mWorkspaceOperationsMonitor,
+                    mPendingChangesUpdater,
+                    mSaveAssets,
+                    mGuiMessage,
+                    mMergeViewLauncher,
+                    mGluonViewSwitcher))
+                return;
+
+            RefreshAsset.UnityAssetDatabase(mAssetStatusCache);
+        }
+
+        void IAssetMenuUVCSOperations.Undo()
+        {
+            List<string> selectedPaths = GetSelectedPaths.ForOperation(
+                mWkInfo,
+                mAssetSelection.GetSelectedAssets(),
+                mPlasticAPI,
+                mAssetStatusCache,
+                AssetMenuOperations.Undo);
+
+            mSaveAssets.ForPathsWithoutConfirmation(
+                mWkInfo.ClientPath, selectedPaths, mWorkspaceOperationsMonitor);
+
+            if (mIsGluonMode)
+            {
+                GluonUndoCheckoutOperation.UndoCheckout(
+                    mWkInfo,
+                    mViewHost,
+                    mProgressControls,
+                    selectedPaths.ToArray(),
+                    false,
+                    mPendingChangesUpdater,
+                    mGluonIncomingChangesUpdater,
+                    () => RefreshAsset.UnityAssetDatabase(mAssetStatusCache));
+                return;
+            }
+
+            UndoCheckoutOperation.Run(
+                mWorkspaceWindow,
+                null,
+                mProgressControls,
+                selectedPaths,
+                mPendingChangesUpdater,
+                mDeveloperIncomingChangesUpdater,
+                mShelvedChangesUpdater,
+                () => RefreshAsset.UnityAssetDatabase(mAssetStatusCache));
+        }
+
+        void IAssetMenuUVCSOperations.ShowDiff()
+        {
+            string selectedPath = AssetsSelection.GetSelectedPath(
+                mWkInfo.ClientPath,
+                mAssetSelection.GetSelectedAssets());
+
+            DiffInfo diffInfo = null;
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    string symbolicName = GetSymbolicName(mWkInfo, selectedPath);
+                    string extension = Path.GetExtension(selectedPath);
+
+                    diffInfo = PlasticGui.Plastic.API.BuildDiffInfoForDiffWithPrevious(
+                        selectedPath, symbolicName, selectedPath, extension, mWkInfo);
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    if (waiter.Exception != null)
+                    {
+                        ExceptionsHandler.DisplayException(waiter.Exception);
+                        return;
+                    }
+
+                    DiffOperation.DiffWithPrevious(
+                        diffInfo,
+                        PlasticExeLauncher.BuildForShowDiff(mWkInfo, mIsGluonMode, mShowDownloadPlasticExeWindow),
+                        null);
+                });
+        }
+
+        void IAssetMenuUVCSOperations.ShowHistory()
+        {
+            Asset selectedAsset = AssetsSelection.GetSelectedAsset(
+                mWkInfo.ClientPath,
+                mAssetSelection.GetSelectedAssets());
+
+            string selectedPath = AssetsPath.GetFullPath.ForPath(selectedAsset.path);
+
+            WorkspaceTreeNode node = PlasticGui.Plastic.API.
+                GetWorkspaceTreeNode(mWkInfo, selectedPath);
+
+            mHistoryViewLauncher.ShowHistoryView(
+                node.RepSpec,
+                node.RevInfo.ItemId,
+                selectedPath,
+                selectedAsset.isFolder);
+        }
+
+        void IAssetFilesFilterPatternsMenuOperations.AddFilesFilterPatterns(
+            FilterTypes type,
+            FilterActions action,
+            FilterOperationType operation)
+        {
+            List<string> selectedPaths = AssetsSelection.GetSelectedPaths(
+                mWkInfo.ClientPath,
+                mAssetSelection.GetSelectedAssets());
+
+            string[] rules = FilterRulesGenerator.GenerateRules(
+                selectedPaths, mWkInfo.ClientPath, action, operation);
+
+            bool isApplicableToAllWorkspaces = !mIsGluonMode;
+            bool isAddOperation = operation == FilterOperationType.Add;
+
+            FilterRulesConfirmationData filterRulesConfirmationData =
+                FilterRulesConfirmationDialog.AskForConfirmation(
+                    rules, isAddOperation, isApplicableToAllWorkspaces, EditorWindow.focusedWindow);
+
+            AddFilesFilterPatternsOperation.Run(
+                mWkInfo,
+                mWorkspaceWindow,
+                type,
+                operation,
+                filterRulesConfirmationData,
+                mPendingChangesUpdater);
+        }
+
+        static string GetSymbolicName(WorkspaceInfo wkInfo, string selectedPath)
+        {
+            WorkspaceTreeNode node = PlasticGui.Plastic.API.
+                GetWorkspaceTreeNode(wkInfo, selectedPath);
+
+            string branchName = string.Empty;
+            BranchInfoCache.TryGetBranchName(
+                node.RepSpec, node.RevInfo.BranchId, out branchName);
+
+            string userName = PlasticGui.Plastic.API.GetUserName(
+                node.RepSpec.Server, node.RevInfo.Owner);
+
+            string symbolicName = string.Format(
+                "cs:{0}@{1} {2} {3}",
+                node.RevInfo.Changeset,
+                string.Format("br:{0}", branchName),
+                userName,
+                "Workspace Revision");
+
+            return symbolicName;
+        }
+
+        readonly WorkspaceInfo mWkInfo;
+        readonly IPlasticAPI mPlasticAPI;
+        readonly ViewHost mViewHost;
+        readonly IWorkspaceWindow mWorkspaceWindow;
+        readonly IViewSwitcher mViewSwitcher;
+        readonly IGluonViewSwitcher mGluonViewSwitcher;
+        readonly IMergeViewLauncher mMergeViewLauncher;
+        readonly IHistoryViewLauncher mHistoryViewLauncher;
+        readonly IAssetStatusCache mAssetStatusCache;
+        readonly IAssetSelection mAssetSelection;
+        readonly ISaveAssets mSaveAssets;
+        readonly LaunchTool.IShowDownloadPlasticExeWindow mShowDownloadPlasticExeWindow;
+        readonly WorkspaceOperationsMonitor mWorkspaceOperationsMonitor;
+        readonly PendingChangesUpdater mPendingChangesUpdater;
+        readonly IncomingChangesUpdater mDeveloperIncomingChangesUpdater;
+        readonly GluonIncomingChangesUpdater mGluonIncomingChangesUpdater;
+        readonly ShelvedChangesUpdater mShelvedChangesUpdater;
+        readonly bool mIsGluonMode;
+        readonly GuiMessage.IGuiMessage mGuiMessage;
+        readonly EditorProgressControls mProgressControls;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetUVCSOperations.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetsSelection.cs

@@ -0,0 +1,141 @@
+using System.Collections.Generic;
+using System.IO;
+
+using UnityEditor.VersionControl;
+
+using PlasticGui.WorkspaceWindow.Items;
+using Unity.PlasticSCM.Editor.AssetsOverlays;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal static class AssetsSelection
+    {
+        internal static Asset GetSelectedAsset(
+            string wkPath,
+            AssetList assetList)
+        {
+            if (assetList.Count == 0)
+                return null;
+
+            foreach (Asset asset in assetList)
+            {
+                if (AssetsPath.GetFullPathUnderWorkspace.
+                        ForAsset(wkPath, asset.path) == null)
+                    continue;
+
+                return asset;
+            }
+
+            return null;
+        }
+
+        internal static string GetSelectedPath(
+            string wkPath,
+            AssetList assetList)
+        {
+            Asset result = GetSelectedAsset(wkPath, assetList);
+
+            if (result == null)
+                return null;
+
+            return AssetsPath.GetFullPath.ForPath(result.path);
+        }
+
+        internal static List<string> GetSelectedPaths(
+            string wkPath,
+            IEnumerable<Asset> assetList)
+        {
+            List<string> result = new List<string>();
+
+            foreach (Asset asset in assetList)
+            {
+                string fullPath = AssetsPath.GetFullPathUnderWorkspace.
+                    ForAsset(wkPath, asset.path);
+
+                if (fullPath == null)
+                    continue;
+
+                result.Add(fullPath);
+            }
+
+            return result;
+        }
+
+        internal static SelectedPathsGroupInfo GetSelectedPathsGroupInfo(
+            string wkPath,
+            AssetList assetList,
+            IAssetStatusCache statusCache)
+        {
+            SelectedPathsGroupInfo result = new SelectedPathsGroupInfo();
+
+            if (assetList.Count == 0)
+                return result;
+
+            result.IsRootSelected = false;
+            result.IsCheckedoutEverySelected = true;
+            result.IsDirectoryEverySelected = true;
+            result.IsCheckedinEverySelected = true;
+            result.IsChangedEverySelected = true;
+
+            foreach (Asset asset in assetList)
+            {
+                string fullPath = AssetsPath.GetFullPathUnderWorkspace.
+                    ForAsset(wkPath, asset.path);
+
+                if (fullPath == null)
+                    continue;
+
+                if (MetaPath.IsMetaPath(fullPath))
+                    fullPath = MetaPath.GetPathFromMetaPath(fullPath);
+
+                AssetStatus status = statusCache.GetStatus(fullPath);
+                string assetName = GetAssetName(asset);
+
+                result.IsCheckedoutEverySelected &= ClassifyAssetStatus.IsCheckedOut(status);
+                result.IsDirectoryEverySelected &= asset.isFolder;
+                result.IsCheckedinEverySelected &= false; // TODO: not implemented yet
+                result.IsChangedEverySelected &= false; // TODO: not implemented yet
+
+                result.IsAnyDirectorySelected |= asset.isFolder;
+                result.IsAnyPrivateSelected |= ClassifyAssetStatus.IsPrivate(status) || ClassifyAssetStatus.IsIgnored(status);
+
+                result.FilterInfo.IsAnyIgnoredSelected |= ClassifyAssetStatus.IsIgnored(status);
+                result.FilterInfo.IsAnyHiddenChangedSelected |= ClassifyAssetStatus.IsHiddenChanged(status);
+
+                result.SelectedCount++;
+
+                if (result.SelectedCount == 1)
+                {
+                    result.FirstIsControlled = ClassifyAssetStatus.IsControlled(status);
+                    result.FirstIsDirectory = asset.isFolder;
+
+                    result.FilterInfo.CommonName = assetName;
+                    result.FilterInfo.CommonExtension = Path.GetExtension(assetName);
+                    result.FilterInfo.CommonFullPath = asset.assetPath;
+                    continue;
+                }
+
+                if (result.FilterInfo.CommonName != assetName)
+                    result.FilterInfo.CommonName = null;
+
+                if (result.FilterInfo.CommonExtension != Path.GetExtension(assetName))
+                    result.FilterInfo.CommonExtension = null;
+
+                if (result.FilterInfo.CommonFullPath != asset.assetPath)
+                    result.FilterInfo.CommonFullPath = null;
+            }
+
+            return result;
+        }
+
+        static string GetAssetName(Asset asset)
+        {
+            if (asset.isFolder)
+                return Path.GetFileName(Path.GetDirectoryName(asset.path));
+
+            return asset.fullName;
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/AssetsSelection.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/AddToCloudDriveDialog.cs

@@ -0,0 +1,381 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common.WebApi;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.CloudDrive.Workspaces;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.CloudDrive;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu.Dialogs
+{
+    internal class AddToCloudDriveDialog :
+        PlasticDialog,
+        FillOrganizationsAndProjects.INotify,
+        FillCloudWorkspaces.IAddToCloudDriveDialog
+    {
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 600, 350);
+            }
+        }
+
+        internal static void ShowDialog(
+            string[] assetPaths,
+            IPlasticWebRestApi restApi,
+            IPlasticAPI plasticApi,
+            EditorWindow parentWindow)
+        {
+            AddToCloudDriveDialog dialog = Create(assetPaths, plasticApi);
+
+            dialog.InitializeProposedOrganizationProject(restApi);
+
+            FillOrganizationsAndProjects.LoadOrganizations(
+                restApi,
+                plasticApi,
+                dialog.mProgressControls,
+                dialog);
+
+            ResponseType dialogResult = dialog.RunModal(parentWindow);
+
+            if (dialogResult != ResponseType.Ok)
+                return;
+
+            CloudDriveWindow cloudDriveWindow = ShowWindow.CloudDrive();
+
+            cloudDriveWindow.CopyPaths(
+                dialog.mSelectedOrganization,
+                dialog.mSelectedProject,
+                dialog.mSelectedCloudDrive.WorkspaceInfo,
+                assetPaths,
+                dialog.mCloudDriveRelativePath);
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.Name.AddToUnityCloudDriveTitle.GetString();
+        }
+
+        protected override string GetExplanation()
+        {
+            return PlasticLocalization.Name.AddToCloudDriveDescription.GetString();
+        }
+
+        protected override void DoComponentsArea()
+        {
+            bool isOperationRunning = mProgressControls.ProgressData.IsWaitingAsyncResult;
+
+            GUI.enabled = !isOperationRunning;
+
+            EntryBuilder.CreateComboBoxEntry(
+                PlasticLocalization.Name.OrganizationLabel.GetString(),
+                mSelectedOrganization,
+                mOrganizations,
+                OnOrganizationSelected,
+                ENTRY_WIDTH,
+                ENTRY_X);
+
+            GUILayout.Space(5);
+
+            if (CloudServer.IsUnityOrganization(mSelectedOrganization))
+            {
+                EntryBuilder.CreateComboBoxEntry(
+                    PlasticLocalization.Name.ProjectLabel.GetString(),
+                    mSelectedProject,
+                    mProjects,
+                    OnProjectSelected,
+                    ENTRY_WIDTH,
+                    ENTRY_X);
+
+                GUILayout.Space(5);
+            }
+
+            string selectedDriveName = mSelectedCloudDrive != null ?
+                mSelectedCloudDrive.RepositoryInfo.Name.GetLastPartFromSeparator('/') : string.Empty;
+            List<string> driveNames = mCloudDrives.Select(
+                workspace => workspace.RepositoryInfo.Name.GetLastPartFromSeparator('/')).ToList();
+
+            EntryBuilder.CreateComboBoxEntry(
+                PlasticLocalization.Name.CloudDriveLabel.GetString(),
+                selectedDriveName,
+                driveNames,
+                OnDriveSelected,
+                ENTRY_WIDTH,
+                ENTRY_X);
+
+            GUILayout.Space(10);
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                mCloudDriveRelativePath = EntryBuilder.CreateTextEntry(
+                    PlasticLocalization.Name.RelativePathLabel.GetString(),
+                    mCloudDriveRelativePath,
+                    ENTRY_WIDTH - BROWSE_BUTTON_WIDTH,
+                    ENTRY_X);
+
+                Rect browseButtonRect = new Rect(
+                    ENTRY_X + ENTRY_WIDTH - BROWSE_BUTTON_WIDTH + BUTTON_MARGIN,
+                    GUILayoutUtility.GetLastRect().y,
+                    BROWSE_BUTTON_WIDTH - BUTTON_MARGIN,
+                    20);
+
+                if (GUI.Button(browseButtonRect, "..."))
+                    DoBrowseForPath();
+            }
+
+            GUI.enabled = true;
+        }
+
+        void FillOrganizationsAndProjects.INotify.OrganizationsRetrieved(List<string> organizations)
+        {
+            mOrganizations = organizations;
+
+            mSelectedOrganization = GetDefaultValue(mProposedOrganization, mOrganizations);
+
+            if (mSelectedOrganization == null)
+                return;
+
+            OnOrganizationSelected(mSelectedOrganization);
+
+            Repaint();
+        }
+
+        void FillOrganizationsAndProjects.INotify.ProjectsRetrieved(List<string> projects)
+        {
+            mProjects = projects;
+
+            mSelectedProject = GetDefaultValue(mProposedProject, mProjects);
+
+            if (mSelectedProject == null)
+                return;
+
+            OnProjectSelected(mSelectedProject);
+
+            Repaint();
+        }
+
+        void FillCloudWorkspaces.IAddToCloudDriveDialog.CloudDrivesRetrieved(
+            List<CloudDriveWorkspace> workspaces)
+        {
+            mCloudDrives = workspaces;
+
+            if (mCloudDrives.Count > 0)
+                mSelectedCloudDrive = mCloudDrives[0];
+
+            Repaint();
+        }
+
+        static AddToCloudDriveDialog Create(string[] assetPaths, IPlasticAPI plasticApi)
+        {
+            var instance = CreateInstance<AddToCloudDriveDialog>();
+            instance.IsResizable = false;
+            instance.mPlasticApi = plasticApi;
+
+            instance.mCloudDriveRelativePath = GetProposedCloudDriveRelativePath(assetPaths);
+
+            instance.mEnterKeyAction = instance.OkButtonAction;
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+
+            return instance;
+        }
+
+        void OnOrganizationSelected(object organization)
+        {
+            mSelectedOrganization = organization != null ? organization.ToString() : null;
+            mProposedOrganization = mSelectedOrganization;
+            mSelectedProject = null;
+            mSelectedCloudDrive = null;
+
+            mProjects.Clear();
+            mCloudDrives.Clear();
+
+            if (!CloudServer.IsUnityOrganization(mSelectedOrganization))
+            {
+                OnProjectSelected(string.Empty);
+                return;
+            }
+
+            FillOrganizationsAndProjects.LoadProjects(
+                mSelectedOrganization, mPlasticApi, mProgressControls, this);
+        }
+
+        void OnProjectSelected(object project)
+        {
+            mSelectedProject = project != null ? project.ToString() : null;
+            mProposedProject = mSelectedProject;
+            mSelectedCloudDrive = null;
+
+            mCloudDrives.Clear();
+
+            if (string.IsNullOrEmpty(mSelectedOrganization))
+                return;
+
+            FillCloudWorkspaces.LoadWorkspaces(
+                mSelectedOrganization, mSelectedProject, this, mProgressControls);
+        }
+
+        void OnDriveSelected(object selectedDrive)
+        {
+            string driveName = selectedDrive != null ? selectedDrive.ToString() : null;
+            mSelectedCloudDrive = mCloudDrives.FirstOrDefault(
+                wkInfo =>
+                    wkInfo.RepositoryInfo.Name.GetLastPartFromSeparator('/') == driveName);
+
+            Repaint();
+        }
+
+        void DoBrowseForPath()
+        {
+            if (mSelectedCloudDrive == null)
+            {
+                ((IProgressControls)mProgressControls).ShowError(
+                    PlasticLocalization.Name.SelectCloudDriveFirst.GetString());
+                return;
+            }
+
+            string workspacePath = AssetsPath.GetFullPath.ForPath(mSelectedCloudDrive.WorkspaceInfo.ClientPath);
+
+            string selectedPath = EditorUtility.SaveFolderPanel(
+                PlasticLocalization.Name.SelectDestinationPath.GetString(),
+                workspacePath,
+                "");
+
+            if (string.IsNullOrEmpty(selectedPath))
+                return;
+
+            string selectedFullPath = AssetsPath.GetFullPath.ForPath(selectedPath);
+
+            if (string.IsNullOrEmpty(selectedFullPath))
+                return;
+
+            if (!selectedFullPath.StartsWith(workspacePath))
+            {
+                ((IProgressControls)mProgressControls).ShowError(
+                    PlasticLocalization.Name.PathMustBeWithinWorkspace.GetString());
+                return;
+            }
+
+            ((IProgressControls)mProgressControls).HideProgress();
+
+            if (selectedFullPath == workspacePath)
+            {
+                mCloudDriveRelativePath = "/";
+                return;
+            }
+
+            mCloudDriveRelativePath = selectedFullPath.Substring(workspacePath.Length).Replace('\\', '/');
+        }
+
+        protected override void DoOkButton()
+        {
+            bool isValid = mSelectedCloudDrive != null && mCloudDriveRelativePath.StartsWith("/");
+
+            if (!isValid || mProgressControls.ProgressData.IsWaitingAsyncResult)
+                GUI.enabled = false;
+
+            if (NormalButton(PlasticLocalization.Name.AddToCloudDriveButton.GetString()))
+            {
+                OkButtonAction();
+            }
+
+            GUI.enabled = true;
+        }
+
+        static string GetProposedCloudDriveRelativePath(string[] assetPaths)
+        {
+            if (assetPaths.Length == 0)
+                return string.Empty;
+
+            string commonRoot = Path.GetDirectoryName(
+                assetPaths[0].TrimEnd(
+                    Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
+
+            for (int i = 1; i < assetPaths.Length; i++)
+            {
+                commonRoot = GetCommonRoot(
+                    commonRoot,
+                    Path.GetDirectoryName(
+                        assetPaths[i].TrimEnd(
+                            Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)));
+            }
+
+            return '/' + commonRoot.Replace('\\', '/');
+        }
+
+        static string GetCommonRoot(string path1, string path2)
+        {
+            string[] path1Parts = path1.Split(Path.DirectorySeparatorChar);
+            string[] path2Parts = path2.Split(Path.DirectorySeparatorChar);
+
+            int commonPartsCount = Mathf.Min(path1Parts.Length, path2Parts.Length);
+
+            for (int i = 0; i < commonPartsCount; i++)
+            {
+                if (path1Parts[i] != path2Parts[i])
+                {
+                    commonPartsCount = i;
+                    break;
+                }
+            }
+
+            return string.Join(
+                Path.DirectorySeparatorChar.ToString(),
+                path1Parts,
+                0,
+                commonPartsCount);
+        }
+
+        static string GetDefaultValue(string proposedValue, List<string> values)
+        {
+            if (values.Count == 0)
+                return null;
+
+            if (!string.IsNullOrEmpty(proposedValue) && values.Contains(proposedValue))
+                return proposedValue;
+
+            return values[0];
+        }
+
+        void InitializeProposedOrganizationProject(IPlasticWebRestApi restApi)
+        {
+            GetProposedOrganizationProject.Values proposedOrganizationProject =
+                GetProposedOrganizationProject.FromCloudProjectSettings();
+
+            mProposedOrganization = proposedOrganizationProject != null ?
+                proposedOrganizationProject.Organization :
+                GetDefaultServer.FromConfig(restApi);
+
+            mProposedProject = proposedOrganizationProject != null ?
+                proposedOrganizationProject.Project :
+                Application.productName;
+        }
+
+        List<string> mOrganizations = new List<string>();
+        List<string> mProjects = new List<string>();
+        List<CloudDriveWorkspace> mCloudDrives = new List<CloudDriveWorkspace>();
+
+        string mProposedOrganization;
+        string mProposedProject;
+        string mSelectedOrganization;
+        string mSelectedProject;
+        CloudDriveWorkspace mSelectedCloudDrive;
+        string mCloudDriveRelativePath;
+
+        IPlasticAPI mPlasticApi;
+
+        const float ENTRY_WIDTH = 400;
+        const float ENTRY_X = 120f;
+        const float BROWSE_BUTTON_WIDTH = 30;
+        const float BUTTON_MARGIN = 5;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/AddToCloudDriveDialog.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/CheckinDialog.cs

@@ -0,0 +1,391 @@
+using System.Collections.Generic;
+using System.IO;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common;
+using Codice.Client.Common.EventTracking;
+using Codice.CM.Common;
+using GluonGui;
+using PlasticGui;
+using PlasticGui.Gluon;
+using PlasticGui.WorkspaceWindow;
+using Unity.PlasticSCM.Editor.AssetsOverlays;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.AssetUtils.Processor;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+#if !UNITY_6000_3_OR_NEWER
+using EditorGUI = Unity.PlasticSCM.Editor.UnityInternals.UnityEditor.EditorGUI;
+#endif
+
+namespace Unity.PlasticSCM.Editor.AssetMenu.Dialogs
+{
+    internal class CheckinDialog : PlasticDialog
+    {
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 700, 450);
+            }
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.CheckinChanges);
+        }
+
+        internal static bool CheckinPaths(
+            WorkspaceInfo wkInfo,
+            List<string> paths,
+            IAssetStatusCache assetStatusCache,
+            bool isGluonMode,
+            IWorkspaceWindow workspaceWindow,
+            ViewHost viewHost,
+            WorkspaceOperationsMonitor workspaceOperationsMonitor,
+            IPendingChangesUpdater pendingChangesUpdater,
+            ISaveAssets saveAssets,
+            GuiMessage.IGuiMessage guiMessage,
+            IMergeViewLauncher mergeViewLauncher,
+            IGluonViewSwitcher gluonViewSwitcher)
+        {
+            MetaCache metaCache = new MetaCache();
+            metaCache.Build(paths);
+
+            CheckinDialog dialog = Create(
+                wkInfo,
+                paths,
+                assetStatusCache,
+                metaCache,
+                isGluonMode,
+                workspaceWindow,
+                viewHost,
+                workspaceOperationsMonitor,
+                pendingChangesUpdater,
+                saveAssets,
+                guiMessage,
+                mergeViewLauncher,
+                gluonViewSwitcher);
+
+            return dialog.RunModal(focusedWindow) == ResponseType.Ok;
+        }
+
+        protected override void DoComponentsArea()
+        {
+            Title(PlasticLocalization.GetString(PlasticLocalization.Name.CheckinOnlyComment));
+
+            Rect commentRect = GUILayoutUtility.GetRect(
+                new GUIContent(string.Empty),
+                EditorStyles.textArea,
+                GUILayout.MinHeight(120),
+                GUILayout.ExpandWidth(true));
+
+            GUI.SetNextControlName(CHECKIN_TEXTAREA_NAME);
+
+            mComment = EditorGUI.ScrollableTextAreaInternal(
+                commentRect,
+                mComment,
+                ref mScrollPosition,
+                EditorStyles.textArea);
+
+            if (!mTextAreaFocused)
+            {
+                UnityEditor.EditorGUI.FocusTextInControl(CHECKIN_TEXTAREA_NAME);
+                mTextAreaFocused = true;
+            }
+
+            Title(PlasticLocalization.GetString(PlasticLocalization.Name.Files));
+
+            DoFileList(
+                mWkInfo,
+                mPaths,
+                mAssetStatusCache,
+                mMetaCache);
+        }
+
+        void DoFileList(
+            WorkspaceInfo wkInfo,
+            List<string> paths,
+            IAssetStatusCache assetStatusCache,
+            MetaCache metaCache)
+        {
+            mFileListScrollPosition = GUILayout.BeginScrollView(
+                mFileListScrollPosition,
+                EditorStyles.helpBox,
+                GUILayout.ExpandHeight(true));
+
+            foreach (string path in paths)
+            {
+                if (MetaPath.IsMetaPath(path))
+                    continue;
+
+                Texture fileIcon = Directory.Exists(path) ?
+                    Images.GetFolderIcon() :
+                    Images.GetFileIcon(path);
+
+                string label = WorkspacePath.GetWorkspaceRelativePath(
+                    wkInfo.ClientPath, path);
+
+                if (metaCache.HasMeta(path))
+                    label = string.Concat(label, UnityConstants.TREEVIEW_META_LABEL);
+
+                AssetsOverlays.AssetStatus assetStatus =
+                    assetStatusCache.GetStatus(path);
+
+                Rect selectionRect = EditorGUILayout.GetControlRect(
+                    true,
+                    UnityConstants.TREEVIEW_ROW_HEIGHT);
+
+                DoListViewItem(selectionRect, fileIcon, label, assetStatus);
+            }
+
+            GUILayout.EndScrollView();
+        }
+
+        void DoListViewItem(
+            Rect itemRect,
+            Texture fileIcon,
+            string label,
+            AssetsOverlays.AssetStatus statusToDraw)
+        {
+            int iconPadding = 2;
+
+            Texture overlayIcon = DrawAssetOverlayIcon.GetOverlayIcon(statusToDraw);
+
+            itemRect = DrawTreeViewItem.DrawIconLeft(
+                itemRect,
+                itemRect.height - 2 * iconPadding,
+                fileIcon,
+                null,
+                overlayIcon);
+
+            GUI.Label(itemRect, label);
+        }
+
+        internal override void OkButtonAction()
+        {
+            if (!IsCheckinButtonEnabled())
+                return;
+
+            bool isCancelled;
+            mSaveAssets.ForPathsWithConfirmation(
+                mWkInfo.ClientPath, mPaths, mWorkspaceOperationsMonitor,
+                out isCancelled);
+
+            if (isCancelled)
+                return;
+
+            mIsRunningCheckin = true;
+
+            mPaths.AddRange(mMetaCache.GetExistingMeta(mPaths));
+
+            if (mIsGluonMode)
+            {
+                CheckinDialogOperations.CheckinPathsPartial(
+                    mWkInfo,
+                    mPaths,
+                    mComment,
+                    mViewHost,
+                    this,
+                    mGuiMessage,
+                    mProgressControls,
+                    mGluonViewSwitcher,
+                    mPendingChangesUpdater);
+                return;
+            }
+
+            CheckinDialogOperations.CheckinPaths(
+                mWkInfo,
+                mPaths,
+                mComment,
+                mWorkspaceWindow,
+                this,
+                mGuiMessage,
+                mProgressControls,
+                mMergeViewLauncher,
+                mPendingChangesUpdater);
+        }
+
+        protected override void DoOkButton()
+        {
+            GUI.enabled = IsCheckinButtonEnabled();
+
+            try
+            {
+                if (!NormalButton(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.CheckinButton)))
+                    return;
+            }
+            finally
+            {
+                if (!mSentCheckinTrackEvent)
+                {
+                    TrackFeatureUseEvent.For(
+                        PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
+                        TrackFeatureUseEvent.Features.UnityPackage.ContextMenuCheckinDialogCheckin);
+
+                    mSentCheckinTrackEvent = true;
+                }
+
+                GUI.enabled = true;
+            }
+
+            OkButtonAction();
+        }
+
+        internal override void CancelButtonAction()
+        {
+            if (!mSentCancelTrackEvent)
+            {
+                TrackFeatureUseEvent.For(
+                    PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
+                    TrackFeatureUseEvent.Features.UnityPackage.ContextMenuCheckinDialogCancel);
+
+                mSentCancelTrackEvent = true;
+            }
+
+            base.CancelButtonAction();
+        }
+
+        bool IsCheckinButtonEnabled()
+        {
+            return !string.IsNullOrEmpty(mComment) && !mIsRunningCheckin;
+        }
+
+        static CheckinDialog Create(
+            WorkspaceInfo wkInfo,
+            List<string> paths,
+            IAssetStatusCache assetStatusCache,
+            MetaCache metaCache,
+            bool isGluonMode,
+            IWorkspaceWindow workspaceWindow,
+            ViewHost viewHost,
+            WorkspaceOperationsMonitor workspaceOperationsMonitor,
+            IPendingChangesUpdater pendingChangesUpdater,
+            ISaveAssets saveAssets,
+            GuiMessage.IGuiMessage guiMessage,
+            IMergeViewLauncher mergeViewLauncher,
+            IGluonViewSwitcher gluonViewSwitcher)
+        {
+            var instance = CreateInstance<CheckinDialog>();
+            instance.IsResizable = true;
+            instance.minSize = new Vector2(520, 370);
+            instance.mWkInfo = wkInfo;
+            instance.mPaths = paths;
+            instance.mAssetStatusCache = assetStatusCache;
+            instance.mMetaCache = metaCache;
+            instance.mIsGluonMode = isGluonMode;
+            instance.mWorkspaceWindow = workspaceWindow;
+            instance.mViewHost = viewHost;
+            instance.mWorkspaceOperationsMonitor = workspaceOperationsMonitor;
+            instance.mPendingChangesUpdater = pendingChangesUpdater;
+            instance.mSaveAssets = saveAssets;
+            instance.mGuiMessage = guiMessage;
+            instance.mMergeViewLauncher = mergeViewLauncher;
+            instance.mGluonViewSwitcher = gluonViewSwitcher;
+            instance.mEnterKeyAction = instance.OkButtonAction;
+            instance.AddControlConsumingEnterKey(CHECKIN_TEXTAREA_NAME);
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+            return instance;
+        }
+
+        WorkspaceInfo mWkInfo;
+        List<string> mPaths;
+        IAssetStatusCache mAssetStatusCache;
+        MetaCache mMetaCache;
+        bool mIsGluonMode;
+        bool mTextAreaFocused;
+        string mComment;
+
+        bool mIsRunningCheckin;
+        Vector2 mFileListScrollPosition;
+
+        // IMGUI evaluates every frame, need to make sure feature tracks get sent only once
+        bool mSentCheckinTrackEvent = false;
+        bool mSentCancelTrackEvent = false;
+
+        IWorkspaceWindow mWorkspaceWindow;
+        WorkspaceOperationsMonitor mWorkspaceOperationsMonitor;
+        IPendingChangesUpdater mPendingChangesUpdater;
+        ISaveAssets mSaveAssets;
+        ViewHost mViewHost;
+        IMergeViewLauncher mMergeViewLauncher;
+        IGluonViewSwitcher mGluonViewSwitcher;
+        GuiMessage.IGuiMessage mGuiMessage;
+
+        const string CHECKIN_TEXTAREA_NAME = "checkin_textarea";
+
+        Vector2 mScrollPosition;
+
+        class MetaCache
+        {
+            internal bool HasMeta(string path)
+            {
+                return mCache.Contains(MetaPath.GetMetaPath(path));
+            }
+
+            internal List<string> GetExistingMeta(List<string> paths)
+            {
+                List<string> result = new List<string>();
+
+                foreach (string path in paths)
+                {
+                    string metaPath = MetaPath.GetMetaPath(path);
+
+                    if (!mCache.Contains(metaPath))
+                        continue;
+
+                    result.Add(metaPath);
+                }
+
+                return result;
+            }
+
+            internal void Build(List<string> paths)
+            {
+                HashSet<string> indexedKeys = BuildIndexedKeys(paths);
+
+                for (int i = paths.Count - 1; i >= 0; i--)
+                {
+                    string currentPath = paths[i];
+
+                    if (!MetaPath.IsMetaPath(currentPath))
+                        continue;
+
+                    string realPath = MetaPath.GetPathFromMetaPath(currentPath);
+
+                    if (!indexedKeys.Contains(realPath))
+                        continue;
+
+                    // found foo.c and foo.c.meta
+                    // with the same chage types - move .meta to cache
+                    mCache.Add(currentPath);
+                    paths.RemoveAt(i);
+                }
+            }
+
+            static HashSet<string> BuildIndexedKeys(List<string> paths)
+            {
+                HashSet<string> result = new HashSet<string>();
+
+                foreach (string path in paths)
+                {
+                    if (MetaPath.IsMetaPath(path))
+                        continue;
+
+                    result.Add(path);
+                }
+
+                return result;
+            }
+
+            HashSet<string> mCache = new HashSet<string>();
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/CheckinDialog.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/CheckinDialogOperations.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+
+using Codice.Client.BaseCommands;
+using Codice.Client.Commands;
+using Codice.Client.Commands.CheckIn;
+using Codice.Client.Common;
+using Codice.Client.Common.Threading;
+using Codice.CM.Common;
+using Codice.CM.Common.Checkin.Partial;
+using GluonGui;
+using PlasticGui;
+using PlasticGui.Gluon;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.PendingChanges;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu.Dialogs
+{
+    internal static class CheckinDialogOperations
+    {
+        internal static void CheckinPaths(
+            WorkspaceInfo wkInfo,
+            List<string> paths,
+            string comment,
+            IWorkspaceWindow workspaceWindow,
+            CheckinDialog dialog,
+            GuiMessage.IGuiMessage guiMessage,
+            IProgressControls progressControls,
+            IMergeViewLauncher mergeViewLauncher,
+            IPendingChangesUpdater pendingChangesUpdater)
+        {
+            BaseCommandsImpl baseCommands = new BaseCommandsImpl();
+
+            progressControls.ShowProgress("Checkin in files");
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    ApplyLocalChanges(wkInfo, paths);
+
+                    CheckinParams ciParams = new CheckinParams();
+                    ciParams.paths = paths.ToArray();
+                    ciParams.comment = comment;
+                    ciParams.time = DateTime.MinValue;
+                    ciParams.flags = CheckinFlags.Recurse | CheckinFlags.ProcessSymlinks;
+
+                    baseCommands.CheckIn(wkInfo, ciParams);
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    progressControls.HideProgress();
+                    ((IPlasticDialogCloser)dialog).CloseDialog();
+
+                    if (waiter.Exception is CmClientMergeNeededException)
+                    {
+                        // we need to explicitly call EditorWindow.Close() to ensure
+                        // that the dialog is closed before asking the user
+                        dialog.Close();
+
+                        if (!UserWantsToShowIncomingView(guiMessage))
+                            return;
+
+                        ShowIncomingChanges.FromCheckin(
+                            wkInfo,
+                            mergeViewLauncher,
+                            progressControls);
+
+                        return;
+                    }
+
+                    if (waiter.Exception != null)
+                    {
+                        ExceptionsHandler.DisplayException(waiter.Exception);
+                        return;
+                    }
+
+                    if (pendingChangesUpdater != null)
+                        pendingChangesUpdater.Update(DateTime.Now);
+
+                    workspaceWindow.RefreshView(ViewType.HistoryView);
+                    workspaceWindow.RefreshView(ViewType.BranchesView);
+                    workspaceWindow.RefreshView(ViewType.ChangesetsView);
+                    workspaceWindow.RefreshView(ViewType.LocksView);
+                });
+        }
+
+        internal static void CheckinPathsPartial(
+            WorkspaceInfo wkInfo,
+            List<string> paths,
+            string comment,
+            ViewHost viewHost,
+            CheckinDialog dialog,
+            GuiMessage.IGuiMessage guiMessage,
+            IProgressControls progressControls,
+            IGluonViewSwitcher gluonViewSwitcher,
+            IPendingChangesUpdater pendingChangesUpdater)
+        {
+            BaseCommandsImpl baseCommands = new BaseCommandsImpl();
+
+            progressControls.ShowProgress(PlasticLocalization.GetString(
+                PlasticLocalization.Name.CheckinInFilesProgress));
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    ApplyLocalChanges(wkInfo, paths);
+
+                    baseCommands.PartialCheckin(wkInfo, paths, comment);
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    progressControls.HideProgress();
+
+                    ((IPlasticDialogCloser)dialog).CloseDialog();
+
+                    if (waiter.Exception is CheckinConflictsException)
+                    {
+                        // we need to explicitly call EditorWindow.Close() to ensure
+                        // that the dialog is closed before asking the user
+                        dialog.Close();
+
+                        if (!UserWantsToShowIncomingView(guiMessage))
+                            return;
+
+                        gluonViewSwitcher.ShowIncomingChangesView();
+                        return;
+                    }
+
+                    if (waiter.Exception != null)
+                    {
+                        ExceptionsHandler.DisplayException(waiter.Exception);
+                        return;
+                    }
+
+                    if (pendingChangesUpdater != null)
+                        pendingChangesUpdater.Update(DateTime.Now);
+
+                    viewHost.RefreshView(ViewType.HistoryView);
+                    viewHost.RefreshView(ViewType.LocksView);
+                });
+        }
+
+        static bool UserWantsToShowIncomingView(GuiMessage.IGuiMessage guiMessage)
+        {
+            GuiMessage.GuiMessageResponseButton result = guiMessage.ShowQuestion(
+                PlasticLocalization.GetString(PlasticLocalization.Name.CheckinConflictsTitle),
+                PlasticLocalization.GetString(PlasticLocalization.Name.UnityCheckinConflictsExplanation),
+                PlasticLocalization.GetString(PlasticLocalization.Name.CheckinShowIncomingChangesView),
+                PlasticLocalization.GetString(PlasticLocalization.Name.CancelButton),
+                null);
+
+            return result == GuiMessage.GuiMessageResponseButton.Positive;
+        }
+
+        static void ApplyLocalChanges(WorkspaceInfo wkInfo, List<string> paths)
+        {
+            ApplyLocalChangesOptions options = new ApplyLocalChangesOptions();
+            options.bIncludeDependencies = true;
+            options.MatchingOptions = new MovedMatchingOptions();
+            options.TypesToApply =
+                ChangeTypes.Changed |
+                ChangeTypes.Private |
+                ChangeTypes.LocallyDeleted |
+                ChangeTypes.LocallyMoved;
+            options.Operation = DependenciesOperation.Checkin;
+            options.bProcessSymlinks = true;
+
+            ApplyChanges.Apply(wkInfo, paths, options, null, out _, out _);
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/Dialogs/CheckinDialogOperations.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/HierarchyViewAssetMenu.cs

@@ -0,0 +1,341 @@
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEditor.VersionControl;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+using Codice.Client.Common.EventTracking;
+using Codice.CM.Common;
+using Codice.LogWrapper;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.AssetUtils.Processor;
+using Unity.PlasticSCM.Editor.Tool;
+using Unity.PlasticSCM.Editor.UI;
+using GluonIncomingChangesUpdater = PlasticGui.Gluon.WorkspaceWindow.IncomingChangesUpdater;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal static class HierarchyViewAssetMenu
+    {
+        internal static void Enable(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            IAssetStatusCache assetStatusCache)
+        {
+            if (mIsEnabled)
+                return;
+
+            mLog.Debug("Enable");
+
+            mWkInfo = wkInfo;
+            mPlasticAPI = plasticApi;
+            mAssetStatusCache = assetStatusCache;
+
+            mIsEnabled = true;
+
+            mAssetSelection = new HierarchyViewAssetSelection();
+
+            mAssetMenuCopyPathOperation = new AssetCopyPathOperation(
+                wkInfo, mPlasticAPI, assetStatusCache, mAssetSelection);
+
+            SceneHierarchyHooks.addItemsToSceneHeaderContextMenu += OnSceneHeaderContextMenu;
+            SceneHierarchyHooks.addItemsToSubSceneHeaderContextMenu += OnSubSceneHeaderContextMenu;
+            SceneHierarchyHooks.addItemsToGameObjectContextMenu += OnGameObjectContextMenu;
+        }
+
+        internal static void Disable()
+        {
+            mLog.Debug("Enable");
+
+            mIsEnabled = false;
+
+            mWkInfo = null;
+            mPlasticAPI = null;
+            mAssetStatusCache = null;
+            mAssetSelection = null;
+            mAssetMenuUVCSOperations = null;
+            mAssetMenuCopyPathOperation = null;
+
+            SceneHierarchyHooks.addItemsToSceneHeaderContextMenu -= OnSceneHeaderContextMenu;
+            SceneHierarchyHooks.addItemsToSubSceneHeaderContextMenu -= OnSubSceneHeaderContextMenu;
+            SceneHierarchyHooks.addItemsToGameObjectContextMenu -= OnGameObjectContextMenu;
+        }
+
+        internal static void BuildOperations(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            GluonGui.ViewHost viewHost,
+            WorkspaceWindow workspaceWindow,
+            IViewSwitcher viewSwitcher,
+            PlasticGui.Gluon.IGluonViewSwitcher gluonViewSwitcher,
+            IMergeViewLauncher mergeViewLauncher,
+            IHistoryViewLauncher historyViewLauncher,
+            IAssetStatusCache assetStatusCache,
+            ISaveAssets saveAssets,
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            WorkspaceOperationsMonitor workspaceOperationsMonitor,
+            PendingChangesUpdater pendingChangesUpdater,
+            IncomingChangesUpdater developerIncomingChangesUpdater,
+            GluonIncomingChangesUpdater gluonIncomingChangesUpdater,
+            ShelvedChangesUpdater shelvedChangesUpdater,
+            bool isGluonMode)
+        {
+            if (!mIsEnabled)
+                Enable(wkInfo, plasticApi, assetStatusCache);
+
+            AssetUVCSOperations assetUVCSOperations = new AssetUVCSOperations(
+                wkInfo,
+                plasticApi,
+                viewHost,
+                workspaceWindow,
+                viewSwitcher,
+                gluonViewSwitcher,
+                mergeViewLauncher,
+                historyViewLauncher,
+                assetStatusCache,
+                mAssetSelection,
+                saveAssets,
+                showDownloadPlasticExeWindow,
+                workspaceOperationsMonitor,
+                pendingChangesUpdater,
+                developerIncomingChangesUpdater,
+                gluonIncomingChangesUpdater,
+                shelvedChangesUpdater,
+                isGluonMode);
+
+            mAssetMenuUVCSOperations = assetUVCSOperations;
+        }
+
+        static void OnSceneHeaderContextMenu(GenericMenu menu, Scene scene)
+        {
+            LoadMenuForAssetPath(menu, scene.path);
+        }
+
+        static void OnSubSceneHeaderContextMenu(GenericMenu menu, SceneHierarchyHooks.SubSceneInfo subSceneInfo)
+        {
+            LoadMenuForAssetPath(menu, subSceneInfo.scene.path);
+        }
+
+        static void OnGameObjectContextMenu(GenericMenu menu, GameObject gameObject)
+        {
+            string prefabAssetPath;
+            if (TryGetAssetPathForPrefab(gameObject, out prefabAssetPath))
+            {
+                LoadMenuForAssetPath(menu, prefabAssetPath);
+            }
+        }
+
+        static bool TryGetAssetPathForPrefab(GameObject gameObject, out string assetPath)
+        {
+            assetPath = null;
+
+            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+
+            if (prefabStage != null && prefabStage.prefabContentsRoot == gameObject)
+            {
+                assetPath = prefabStage.assetPath;
+            }
+
+            return assetPath != null;
+        }
+
+        static void LoadMenuForAssetPath(GenericMenu menu, string assetPath)
+        {
+            string assetFullPath = AssetsPath.GetFullPathUnderWorkspace.ForAsset(mWkInfo.ClientPath, assetPath);
+
+            if (assetFullPath == null)
+                return;
+
+            mAssetSelection.SetActiveAsset(new Asset(assetFullPath));
+
+            AddItemsToMenu(menu);
+        }
+
+        static void AddItemsToMenu(GenericMenu menu)
+        {
+            menu.AddSeparator(string.Empty);
+
+            menu.AddItem(
+                GetPlasticMenuItemContent(PlasticLocalization.Name.PendingChangesPlasticMenu),
+                false,
+                PendingChanges);
+
+            menu.AddSeparator(GetSubMenuName());
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.AddPlasticMenu),
+                Add,
+                AssetMenuOperations.Add
+            );
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.CheckoutPlasticMenu),
+                Checkout,
+                AssetMenuOperations.Checkout
+            );
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.CheckinPlasticMenu),
+                Checkin,
+                AssetMenuOperations.Checkin
+            );
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.UndoPlasticMenu),
+                Undo,
+                AssetMenuOperations.Undo
+            );
+
+            menu.AddSeparator(GetSubMenuName());
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.CopyFilePathMenuItem),
+                CopyFilePath,
+                AssetMenuOperations.CopyFilePath
+            );
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.CopyRelativeFilePathMenuItem),
+                CopyRelativeFilePath,
+                AssetMenuOperations.CopyFilePath
+            );
+
+            menu.AddSeparator(GetSubMenuName());
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.DiffPlasticMenu),
+                Diff,
+                AssetMenuOperations.Diff
+            );
+
+            AddMenuItemForConditionalOperation(
+                menu,
+                GetPlasticMenuItemContent(PlasticLocalization.Name.HistoryPlasticMenu),
+                History,
+                AssetMenuOperations.History
+            );
+        }
+
+        static void AddMenuItemForConditionalOperation(
+            GenericMenu menu,
+            GUIContent menuContent,
+            GenericMenu.MenuFunction menuAction,
+            AssetMenuOperations operation)
+        {
+            if (ValidateOperation(operation))
+            {
+                menu.AddItem(menuContent, false, menuAction);
+            }
+            else
+            {
+                menu.AddDisabledItem(menuContent);
+            }
+        }
+
+        static void PendingChanges()
+        {
+            ShowWindow.UVCS();
+            mAssetMenuUVCSOperations.ShowPendingChanges();
+        }
+
+        static void Add()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Add();
+        }
+
+        static void Checkout()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Checkout();
+        }
+
+        static void Checkin()
+        {
+            TrackFeatureUseEvent.For(
+                PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
+                TrackFeatureUseEvent.Features.UnityPackage.HierarchyContextMenuCheckinOption);
+
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Checkin();
+        }
+
+        static void Undo()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Undo();
+        }
+
+        static void CopyFilePath()
+        {
+            mAssetMenuCopyPathOperation.CopyFilePath(relativePath: false);
+        }
+
+        static void CopyRelativeFilePath()
+        {
+            mAssetMenuCopyPathOperation.CopyFilePath(relativePath: true);
+        }
+
+        static void Diff()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.ShowDiff();
+        }
+
+        static void History()
+        {
+            ShowWindow.UVCS();
+            mAssetMenuUVCSOperations.ShowHistory();
+        }
+
+        static bool ValidateOperation(AssetMenuOperations operation)
+        {
+            return AssetMenuUpdater.ShouldMenuOperationBeEnabled(
+                mWkInfo, mPlasticAPI, mAssetSelection, mAssetStatusCache, operation);
+        }
+
+        static GUIContent GetPlasticMenuItemContent(PlasticLocalization.Name name)
+        {
+            string menuText = string.Format("{0}{1}",
+                GetSubMenuName(),
+                name.GetString());
+
+            return EditorGUIUtility.TrTextContent(menuText);
+        }
+
+        static string GetSubMenuName()
+        {
+            return PlasticLocalization.Name.UnityVersionControl.GetString() + "/";
+        }
+
+        static bool mIsEnabled;
+        static WorkspaceInfo mWkInfo;
+        static IPlasticAPI mPlasticAPI;
+        static IAssetStatusCache mAssetStatusCache;
+        static HierarchyViewAssetSelection mAssetSelection;
+        static IAssetMenuUVCSOperations mAssetMenuUVCSOperations;
+        static IAssetMenuCopyPathOperation mAssetMenuCopyPathOperation;
+
+        static readonly ILog mLog = PlasticApp.GetLogger("HierarchyViewMenu");
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/HierarchyViewAssetMenu.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c50ac3c60fd045b38f5449bb43db257d
+timeCreated: 1751878870

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/HierarchyViewAssetSelection.cs

@@ -0,0 +1,19 @@
+using UnityEditor.VersionControl;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal class HierarchyViewAssetSelection : AssetUVCSOperations.IAssetSelection
+    {
+        AssetList AssetUVCSOperations.IAssetSelection.GetSelectedAssets()
+        {
+            return mSelectedAsset != null ? new AssetList() { mSelectedAsset } : new AssetList();
+        }
+
+        internal void SetActiveAsset(Asset asset)
+        {
+            mSelectedAsset = asset;
+        }
+
+        Asset mSelectedAsset;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/HierarchyViewAssetSelection.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 19397b4b199145c5bd9ee8c1c7d5938d
+timeCreated: 1751879990

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewAssetSelection.cs

@@ -0,0 +1,61 @@
+using System;
+
+using UnityEditor;
+using UnityEditor.VersionControl;
+
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal class ProjectViewAssetSelection : AssetUVCSOperations.IAssetSelection
+    {
+        internal ProjectViewAssetSelection(Action assetSelectionChangedAction)
+        {
+            mAssetSelectionChangedAction = assetSelectionChangedAction;
+
+            Selection.selectionChanged += SelectionChanged;
+        }
+
+        internal void Dispose()
+        {
+            Selection.selectionChanged -= SelectionChanged;
+        }
+
+        void SelectionChanged()
+        {
+            // Selection.selectionChanged gets triggered on both
+            // project view and scene view. We only want to trigger
+            // the action if user selects on project view (has assets)
+            if (HasSelectedAssets())
+                mAssetSelectionChangedAction();
+        }
+
+        AssetList AssetUVCSOperations.IAssetSelection.GetSelectedAssets()
+        {
+            if (Selection.assetGUIDs.Length == 0)
+                return new AssetList();
+
+            AssetList result = new AssetList();
+
+            foreach (string guid in Selection.assetGUIDs)
+            {
+                string assetPath = AssetsPath.GetFullPath.ForGuid(guid);
+
+                if (string.IsNullOrEmpty(assetPath))
+                    continue;
+
+                result.Add(new Asset(assetPath));
+            }
+
+            return result;
+        }
+
+        bool HasSelectedAssets()
+        {
+            // Objects in project view have GUIDs, objects in scene view don't
+            return Selection.assetGUIDs.Length > 0;
+        }
+
+        Action mAssetSelectionChangedAction;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewAssetSelection.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewCloudDriveAssetMenu.cs

@@ -0,0 +1,84 @@
+using System.Linq;
+
+using UnityEditor;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.AssetMenu.Dialogs;
+using Unity.PlasticSCM.Editor.CloudDrive;
+using Unity.PlasticSCM.Editor.CloudDrive.CreateWorkspace;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal static class ProjectViewCloudDriveAssetMenu
+    {
+        internal static void AddMenuItem()
+        {
+            HandleMenuItem.AddMenuItem(
+                PlasticLocalization.Name.AddToUnityCloudDriveMenu.GetString(),
+                ProjectViewUVCSAssetMenu.BASE_MENU_ITEM_PRIORITY,
+                AddToCloudDrive,
+                ValidateAddToCloudDrive);
+
+            HandleMenuItem.UpdateAllMenus();
+        }
+
+        internal static void RemoveMenuItem()
+        {
+            HandleMenuItem.RemoveMenuItem(
+                PlasticLocalization.Name.AddToUnityCloudDriveMenu.GetString());
+        }
+
+        static void AddToCloudDrive()
+        {
+            if (PlasticGuiConfig.Get().Configuration.ShowCloudDriveWelcomeView ||
+                UnityConfigurationChecker.NeedsConfiguration())
+            {
+                ShowWindow.CloudDrive();
+                return;
+            }
+
+            if (!CloudDriveWindow.HasCloudDriveWorkspaces())
+            {
+                CreateWorkspaceDialog.CreateWorkspace(
+                    PlasticGui.Plastic.WebRestAPI,
+                    PlasticGui.Plastic.API,
+                    EditorWindow.focusedWindow,
+                    (createdWorkspace) => { ShowAddToCloudDriveDialog(); });
+                return;
+            }
+
+            ShowAddToCloudDriveDialog();
+        }
+
+        static void ShowAddToCloudDriveDialog()
+        {
+            string[] selectedPaths = GetSelectedAssetPaths();
+
+            if (selectedPaths.Length == 0)
+                return;
+
+            AddToCloudDriveDialog.ShowDialog(
+                selectedPaths,
+                PlasticGui.Plastic.WebRestAPI,
+                PlasticGui.Plastic.API,
+                EditorWindow.focusedWindow);
+        }
+
+        static bool ValidateAddToCloudDrive()
+        {
+            return Selection.assetGUIDs != null && Selection.assetGUIDs.Length > 0;
+        }
+
+        static string[] GetSelectedAssetPaths()
+        {
+            if (Selection.assetGUIDs == null || Selection.assetGUIDs.Length == 0)
+                return new string[0];
+
+            return Selection.assetGUIDs
+                .Select(guid => AssetDatabase.GUIDToAssetPath(guid))
+                .Where(path => !string.IsNullOrEmpty(path))
+                .ToArray();
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewCloudDriveAssetMenu.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9874d2fcd73d40b6940619e9cd482ad4
+timeCreated: 1756131709

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewUVCSAssetMenu.cs

@@ -0,0 +1,351 @@
+using UnityEditor.VersionControl;
+
+using Codice.CM.Common;
+using Codice.Client.Common.EventTracking;
+using Codice.LogWrapper;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.Items;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.AssetUtils.Processor;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.Tool;
+
+using GluonIncomingChangesUpdater = PlasticGui.Gluon.WorkspaceWindow.IncomingChangesUpdater;
+
+namespace Unity.PlasticSCM.Editor.AssetMenu
+{
+    internal static class ProjectViewUVCSAssetMenu
+    {
+        internal static void Enable(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            IAssetStatusCache assetStatusCache)
+        {
+            if (mIsEnabled)
+                return;
+
+            mLog.Debug("Enable");
+
+            mWkInfo = wkInfo;
+            mPlasticAPI = plasticApi;
+            mAssetStatusCache = assetStatusCache;
+
+            mIsEnabled = true;
+
+            mAssetSelection = new ProjectViewAssetSelection(UpdateFilterMenuItems);
+
+            mAssetMenuCopyPathOperation = new AssetCopyPathOperation(
+                wkInfo, mPlasticAPI, assetStatusCache, mAssetSelection);
+
+            mFilterMenuBuilder = new AssetFilesFilterPatternsMenuBuilder(
+                IGNORE_MENU_ITEMS_PRIORITY,
+                HIDDEN_MENU_ITEMS_PRIORITY);
+
+            AddMenuItems();
+        }
+
+        internal static void Disable()
+        {
+            mLog.Debug("Disable");
+
+            mIsEnabled = false;
+
+            RemoveMenuItems();
+
+            if (mAssetSelection != null)
+                mAssetSelection.Dispose();
+
+            mWkInfo = null;
+            mAssetStatusCache = null;
+            mAssetSelection = null;
+            mFilterMenuBuilder = null;
+            mAssetMenuUVCSOperations = null;
+            mAssetMenuCopyPathOperation = null;
+        }
+
+        internal static void BuildOperations(
+            WorkspaceInfo wkInfo,
+            IPlasticAPI plasticApi,
+            GluonGui.ViewHost viewHost,
+            WorkspaceWindow workspaceWindow,
+            IViewSwitcher viewSwitcher,
+            PlasticGui.Gluon.IGluonViewSwitcher gluonViewSwitcher,
+            IMergeViewLauncher mergeViewLauncher,
+            IHistoryViewLauncher historyViewLauncher,
+            IAssetStatusCache assetStatusCache,
+            ISaveAssets saveAssets,
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            WorkspaceOperationsMonitor workspaceOperationsMonitor,
+            PendingChangesUpdater pendingChangesUpdater,
+            IncomingChangesUpdater developerIncomingChangesUpdater,
+            GluonIncomingChangesUpdater gluonIncomingChangesUpdater,
+            ShelvedChangesUpdater shelvedChangesUpdater,
+            bool isGluonMode)
+        {
+            if (!mIsEnabled)
+                Enable(wkInfo, plasticApi, assetStatusCache);
+
+            AssetUVCSOperations assetUVCSOperations = new AssetUVCSOperations(
+                wkInfo,
+                plasticApi,
+                viewHost,
+                workspaceWindow,
+                viewSwitcher,
+                gluonViewSwitcher,
+                mergeViewLauncher,
+                historyViewLauncher,
+                assetStatusCache,
+                mAssetSelection,
+                saveAssets,
+                showDownloadPlasticExeWindow,
+                workspaceOperationsMonitor,
+                pendingChangesUpdater,
+                developerIncomingChangesUpdater,
+                gluonIncomingChangesUpdater,
+                shelvedChangesUpdater,
+                isGluonMode);
+
+            mAssetMenuUVCSOperations = assetUVCSOperations;
+            mFilterMenuBuilder.SetOperations(assetUVCSOperations);
+        }
+
+        static void RemoveMenuItems()
+        {
+            mFilterMenuBuilder.RemoveMenuItems();
+
+            HandleMenuItem.RemoveMenuItem(
+                PlasticLocalization.GetString(PlasticLocalization.Name.PrefixUnityVersionControlMenu));
+
+            HandleMenuItem.UpdateAllMenus();
+        }
+
+        static void UpdateFilterMenuItems()
+        {
+            AssetList assetList = ((AssetUVCSOperations.IAssetSelection)
+                mAssetSelection).GetSelectedAssets();
+
+            SelectedPathsGroupInfo info = AssetsSelection.GetSelectedPathsGroupInfo(
+                mWkInfo.ClientPath, assetList, mAssetStatusCache);
+
+            FilterMenuActions actions =
+                assetList.Count != info.SelectedCount ?
+                new FilterMenuActions() :
+                FilterMenuUpdater.GetMenuActions(info);
+
+            mFilterMenuBuilder.UpdateMenuItems(actions);
+        }
+
+        static void AddMenuItems()
+        {
+            // TODO: Try removing this
+            // Somehow first item always disappears. So this is a filler item
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.PendingChangesPlasticMenu),
+                PENDING_CHANGES_MENU_ITEM_PRIORITY,
+                PendingChanges, ValidatePendingChanges);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.PendingChangesPlasticMenu),
+                PENDING_CHANGES_MENU_ITEM_PRIORITY,
+                PendingChanges, ValidatePendingChanges);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.AddPlasticMenu),
+                ADD_MENU_ITEM_PRIORITY,
+                Add, ValidateAdd);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.CheckoutPlasticMenu),
+                CHECKOUT_MENU_ITEM_PRIORITY,
+                Checkout, ValidateCheckout);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.CheckinPlasticMenu),
+                CHECKIN_MENU_ITEM_PRIORITY,
+                Checkin, ValidateCheckin);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.UndoPlasticMenu),
+                UNDO_MENU_ITEM_PRIORITY,
+                Undo, ValidateUndo);
+
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.CopyFilePathMenuItem),
+                COPY_FILE_PATH_MENU_ITEM_PRIORITY,
+                CopyFilePath,
+                ValidateCopyFilePath);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.CopyRelativeFilePathMenuItem),
+                COPY_RELATIVE_FILE_PATH_MENU_ITEM_PRIORITY,
+                CopyRelativeFilePath,
+                ValidateCopyFilePath);
+
+            UpdateFilterMenuItems();
+
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.DiffPlasticMenu),
+                GetPlasticShortcut.ForAssetDiff(),
+                DIFF_MENU_ITEM_PRIORITY,
+                Diff, ValidateDiff);
+            HandleMenuItem.AddMenuItem(
+                GetPlasticMenuItemName(PlasticLocalization.Name.HistoryPlasticMenu),
+                GetPlasticShortcut.ForHistory(),
+                HISTORY_MENU_ITEM_PRIORITY,
+                History, ValidateHistory);
+
+            HandleMenuItem.UpdateAllMenus();
+        }
+
+        static void PendingChanges()
+        {
+            ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.ShowPendingChanges();
+        }
+
+        static bool ValidatePendingChanges()
+        {
+            return true;
+        }
+
+        static void Add()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Add();
+        }
+
+        static bool ValidateAdd()
+        {
+            return ValidateOperation(AssetMenuOperations.Add);
+        }
+
+        static void Checkout()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Checkout();
+        }
+
+        static bool ValidateCheckout()
+        {
+            return ValidateOperation(AssetMenuOperations.Checkout);
+        }
+
+        static void Checkin()
+        {
+            TrackFeatureUseEvent.For(
+                PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
+                TrackFeatureUseEvent.Features.UnityPackage.ProjectContextMenuCheckinOption);
+
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Checkin();
+        }
+
+        static bool ValidateCheckin()
+        {
+            return ValidateOperation(AssetMenuOperations.Checkin);
+        }
+
+        static void Undo()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.Undo();
+        }
+
+        static bool ValidateUndo()
+        {
+            return ValidateOperation(AssetMenuOperations.Undo);
+        }
+
+        static void CopyFilePath()
+        {
+            mAssetMenuCopyPathOperation.CopyFilePath(relativePath: false);
+        }
+
+        static void CopyRelativeFilePath()
+        {
+            mAssetMenuCopyPathOperation.CopyFilePath(relativePath: true);
+        }
+
+        static bool ValidateCopyFilePath()
+        {
+            return ValidateOperation(AssetMenuOperations.CopyFilePath);
+        }
+
+        static void Diff()
+        {
+            if (mAssetMenuUVCSOperations == null)
+                ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.ShowDiff();
+        }
+
+        static bool ValidateDiff()
+        {
+            return ValidateOperation(AssetMenuOperations.Diff);
+        }
+
+        static void History()
+        {
+            ShowWindow.UVCS();
+
+            mAssetMenuUVCSOperations.ShowHistory();
+        }
+
+        static bool ValidateHistory()
+        {
+            return ValidateOperation(AssetMenuOperations.History);
+        }
+
+        static bool ValidateOperation(AssetMenuOperations operation)
+        {
+            return AssetMenuUpdater.ShouldMenuOperationBeEnabled(
+                mWkInfo, mPlasticAPI, mAssetSelection, mAssetStatusCache, operation);
+        }
+
+        static string GetPlasticMenuItemName(PlasticLocalization.Name name)
+        {
+            return string.Format("{0}/{1}",
+                PlasticLocalization.GetString(PlasticLocalization.Name.PrefixUnityVersionControlMenu),
+                PlasticLocalization.GetString(name));
+        }
+
+        static IAssetMenuUVCSOperations mAssetMenuUVCSOperations;
+        static IAssetMenuCopyPathOperation mAssetMenuCopyPathOperation;
+
+        static ProjectViewAssetSelection mAssetSelection;
+        static AssetFilesFilterPatternsMenuBuilder mFilterMenuBuilder;
+
+        static bool mIsEnabled;
+        static IAssetStatusCache mAssetStatusCache;
+        static IPlasticAPI mPlasticAPI;
+        static WorkspaceInfo mWkInfo;
+
+#if UNITY_6000_0_OR_NEWER
+        // Puts Unity Version Control in a new section, as it precedes the Create menu with the old value
+        internal const int BASE_MENU_ITEM_PRIORITY = 71;
+#else
+        // Puts Unity Version Control right below the Create menu
+        internal const int BASE_MENU_ITEM_PRIORITY = 19;
+#endif
+
+        // incrementing the "order" param by 11 causes the menu system to add a separator
+        const int PENDING_CHANGES_MENU_ITEM_PRIORITY = BASE_MENU_ITEM_PRIORITY;
+        const int ADD_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 11;
+        const int CHECKOUT_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 12;
+        const int CHECKIN_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 13;
+        const int UNDO_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 14;
+        const int COPY_FILE_PATH_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 25;
+        const int COPY_RELATIVE_FILE_PATH_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 26;
+        const int IGNORE_MENU_ITEMS_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 37;
+        const int HIDDEN_MENU_ITEMS_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 38;
+        const int DIFF_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 49;
+        const int HISTORY_MENU_ITEM_PRIORITY = PENDING_CHANGES_MENU_ITEM_PRIORITY + 50;
+
+        static readonly ILog mLog = PlasticApp.GetLogger("ProjectViewAssetMenu");
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetMenu/ProjectViewUVCSAssetMenu.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/AssetOverlay.cs

@@ -0,0 +1,94 @@
+using System;
+
+using PlasticGui;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays
+{
+    internal static class AssetOverlay
+    {
+        internal static string GetStatusString(AssetStatus assetStatus)
+        {
+            if (ClassifyAssetStatus.IsPrivate(assetStatus))
+                return PlasticLocalization.Name.Private.GetString();
+
+            if (ClassifyAssetStatus.IsIgnored(assetStatus))
+                return PlasticLocalization.Name.StatusIgnored.GetString();
+
+            if (ClassifyAssetStatus.IsAdded(assetStatus))
+                return PlasticLocalization.Name.StatusAdded.GetString();
+
+            if (ClassifyAssetStatus.IsConflicted(assetStatus))
+                return PlasticLocalization.Name.StatusConflicted.GetString();
+
+            if (ClassifyAssetStatus.IsDeletedOnServer(assetStatus))
+                return PlasticLocalization.Name.StatusDeletedOnServer.GetString();
+
+            if (ClassifyAssetStatus.IsLockedRemote(assetStatus))
+                return PlasticLocalization.Name.StatusLockedRemote.GetString();
+
+            if (ClassifyAssetStatus.IsOutOfDate(assetStatus))
+                return PlasticLocalization.Name.StatusOutOfDate.GetString();
+
+            if (ClassifyAssetStatus.IsLocked(assetStatus))
+                return PlasticLocalization.Name.StatusLockedByMe.GetString();
+
+            if (ClassifyAssetStatus.IsRetained(assetStatus))
+                return PlasticLocalization.Name.StatusRetained.GetString();
+
+            if (ClassifyAssetStatus.IsCheckedOut(assetStatus))
+                return PlasticLocalization.Name.StatusCheckout.GetString();
+
+            if (ClassifyAssetStatus.IsChanged(assetStatus))
+                return PlasticLocalization.Name.ChangedStatus.GetString();
+
+            if (ClassifyAssetStatus.ContainsChanges(assetStatus))
+                return PlasticLocalization.Name.ContainsChanges.GetString();
+
+            if (ClassifyAssetStatus.IsControlled(assetStatus))
+                return PlasticLocalization.Name.Controlled.GetString();
+
+            return string.Empty;
+        }
+
+        internal static string GetTooltipText(
+            AssetStatus statusValue,
+            LockStatusData lockStatusData)
+        {
+            string statusText = GetStatusString(statusValue);
+
+            if (lockStatusData == null)
+                return statusText;
+
+            // example:
+            // Changed by:
+            // * dani_pen@hotmail.com
+            // * workspace wkLocal"
+
+            char bulletCharacter = '\u25cf';
+
+            string line1 = ClassifyAssetStatus.IsLocked(statusValue) ?
+                statusText + ":" :
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.AssetOverlayTooltipStatus,
+                    statusText);
+
+            string line2 = string.Format("{0} {1}",
+                bulletCharacter,
+                lockStatusData.LockedBy);
+
+            string line3 = string.Format("{0} {1}",
+                bulletCharacter,
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.AssetOverlayTooltipOn,
+                    lockStatusData.HolderBranchName));
+
+            return string.Format(
+                "{0}" + Environment.NewLine +
+                "{1}" + Environment.NewLine +
+                "{2}",
+                line1,
+                line2,
+                line3);
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/AssetOverlay.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 408f89d90a01494cbef838c7d21449a9
+timeCreated: 1750849696

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/AssetStatus.cs

@@ -0,0 +1,120 @@
+using System;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays
+{
+    [Flags]
+    internal enum AssetStatus
+    {
+        None            = 0,
+        Private         = 1 << 0,
+        Ignored         = 1 << 2,
+        Added           = 1 << 3,
+        Checkout        = 1 << 4,
+        Controlled      = 1 << 5,
+        UpToDate        = 1 << 6,
+        Changed         = 1 << 7,
+        ContainsChanges = 1 << 8,
+        OutOfDate       = 1 << 9,
+        Conflicted      = 1 << 10,
+        DeletedOnServer = 1 << 11,
+        Locked          = 1 << 12,
+        LockedRemote    = 1 << 13,
+        Retained        = 1 << 14,
+        HiddenChanged   = 1 << 15,
+    }
+
+    internal class LockStatusData
+    {
+        internal readonly AssetStatus Status;
+        internal readonly string LockedBy;
+        internal readonly string HolderBranchName;
+
+        internal LockStatusData(
+            AssetStatus status,
+            string lockedBy,
+            string holderBranchName)
+        {
+            Status = status;
+            LockedBy = lockedBy;
+            HolderBranchName = holderBranchName;
+        }
+    }
+
+    internal class ClassifyAssetStatus
+    {
+        internal static bool IsPrivate(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Private);
+        }
+
+        internal static bool IsIgnored(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Ignored);
+        }
+
+        internal static bool IsControlled(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Controlled);
+        }
+
+        internal static bool IsLocked(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Locked);
+        }
+
+        internal static bool IsLockedRemote(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.LockedRemote);
+        }
+
+        internal static bool IsRetained(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Retained);
+        }
+
+        internal static bool IsOutOfDate(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.OutOfDate);
+        }
+
+        internal static bool IsDeletedOnServer(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.DeletedOnServer);
+        }
+
+        internal static bool IsConflicted(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Conflicted);
+        }
+
+        internal static bool IsAdded(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Added);
+        }
+
+        internal static bool IsCheckedOut(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Checkout);
+        }
+
+        internal static bool IsChanged(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.Changed);
+        }
+
+        internal static bool ContainsChanges(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.ContainsChanges);
+        }
+
+        internal static bool IsHiddenChanged(AssetStatus status)
+        {
+            return ContainsAny(status, AssetStatus.HiddenChanged);
+        }
+
+        static bool ContainsAny(AssetStatus status, AssetStatus matchTo)
+        {
+            return (status & matchTo) != AssetStatus.None;
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/AssetStatus.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/AssetStatusCache.cs

@@ -0,0 +1,66 @@
+using Codice.CM.Common;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays.Cache
+{
+    internal interface IAssetStatusCache
+    {
+        AssetStatus GetStatus(string fullPath);
+        LockStatusData GetLockStatusData(string fullPath);
+        void Clear();
+        void ClearLocks();
+        void Cancel();
+    }
+
+    internal class AssetStatusCache : IAssetStatusCache
+    {
+        internal AssetStatusCache(
+            WorkspaceInfo wkInfo,
+            bool isGluonMode)
+        {
+            mLocalStatusCache = new LocalStatusCache(wkInfo);
+            mRemoteStatusCache = new RemoteStatusCache(wkInfo, isGluonMode);
+            mLockStatusCache = new LockStatusCache(wkInfo);
+        }
+
+        AssetStatus IAssetStatusCache.GetStatus(string fullPath)
+        {
+            AssetStatus localStatus = mLocalStatusCache.GetStatus(fullPath);
+
+            if (!ClassifyAssetStatus.IsControlled(localStatus))
+                return localStatus;
+
+            AssetStatus remoteStatus = mRemoteStatusCache.GetStatus(fullPath);
+
+            AssetStatus lockStatus = mLockStatusCache.GetStatus(fullPath);
+
+            return localStatus | remoteStatus | lockStatus;
+        }
+
+        LockStatusData IAssetStatusCache.GetLockStatusData(string fullPath)
+        {
+            return mLockStatusCache.GetLockStatusData(fullPath);
+        }
+
+        void IAssetStatusCache.Clear()
+        {
+            mLocalStatusCache.Clear();
+            mRemoteStatusCache.Clear();
+            mLockStatusCache.Clear();
+        }
+
+        void IAssetStatusCache.ClearLocks()
+        {
+            mLockStatusCache.Clear();
+        }
+
+        void IAssetStatusCache.Cancel()
+        {
+            mRemoteStatusCache.Cancel();
+            mLockStatusCache.Cancel();
+        }
+
+        readonly LocalStatusCache mLocalStatusCache;
+        readonly RemoteStatusCache mRemoteStatusCache;
+        readonly LockStatusCache mLockStatusCache;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/AssetStatusCache.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/BuildPathDictionary.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+
+using Codice.Utils;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays.Cache
+{
+    internal static class BuildPathDictionary
+    {
+        internal static Dictionary<string, T> ForPlatform<T>()
+        {
+            if (PlatformIdentifier.IsWindows())
+                return new Dictionary<string, T>(
+                    StringComparer.OrdinalIgnoreCase);
+
+            return new Dictionary<string, T>();
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/BuildPathDictionary.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/LocalStatusCache.cs

@@ -0,0 +1,98 @@
+using System.Collections.Generic;
+
+using Codice;
+using Codice.CM.Common;
+using Codice.Client.BaseCommands;
+using Codice.Client.Commands.WkTree;
+using PlasticGui.WorkspaceWindow;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays.Cache
+{
+    internal class LocalStatusCache
+    {
+        internal LocalStatusCache(WorkspaceInfo wkInfo)
+        {
+            mWkInfo = wkInfo;
+        }
+
+        internal AssetStatus GetStatus(string fullPath)
+        {
+            AssetStatus result;
+
+            if (mStatusByPathCache.TryGetValue(fullPath, out result))
+                return result;
+
+            result = CalculateStatus(
+                mWkInfo,
+                fullPath,
+                FilterManager.Get().GetIgnoredFilter(),
+                FilterManager.Get().GetHiddenChangesFilter());
+
+            mStatusByPathCache.Add(fullPath, result);
+
+            return result;
+        }
+
+        internal void Clear()
+        {
+            mStatusByPathCache.Clear();
+        }
+
+        static AssetStatus CalculateStatus(
+            WorkspaceInfo wkInfo,
+            string fullPath,
+            IgnoredFilesFilter ignoredFilter,
+            HiddenChangesFilesFilter hiddenChangesFilter)
+        {
+            WorkspaceTreeNode node = PlasticGui.Plastic.API.GetWorkspaceTreeNode(
+                wkInfo, fullPath);
+
+            if (CheckWorkspaceTreeNodeStatus.IsPrivate(node))
+            {
+                return ignoredFilter.IsIgnored(fullPath) ?
+                    AssetStatus.Ignored : AssetStatus.Private;
+            }
+
+            if (CheckWorkspaceTreeNodeStatus.IsAdded(node))
+                return AssetStatus.Added;
+
+            AssetStatus status = AssetStatus.Controlled;
+
+            status |= CalculateControlledFlags(wkInfo, fullPath, node);
+            status |= GetHiddenChangeFlag(fullPath, hiddenChangesFilter);
+
+            return status;
+        }
+
+        static AssetStatus CalculateControlledFlags(
+            WorkspaceInfo wkInfo,
+            string fullPath,
+            WorkspaceTreeNode node)
+        {
+            if (CheckWorkspaceTreeNodeStatus.IsCheckedOut(node))
+                return AssetStatus.Checkout;
+
+            if (CheckWorkspaceTreeNodeStatus.IsDirectory(node))
+                return PlasticGui.Plastic.API.IsOnChangedTree(wkInfo, fullPath)
+                    ? AssetStatus.ContainsChanges
+                    : AssetStatus.None;
+
+            return ChangedFileChecker.IsChanged(node.LocalInfo, fullPath, wkInfo.IsDynamic, false)
+                ? AssetStatus.Changed
+                : AssetStatus.None;
+        }
+
+        static AssetStatus GetHiddenChangeFlag(
+            string fullPath,
+            HiddenChangesFilesFilter hiddenChangesFilter)
+        {
+            return hiddenChangesFilter.IsHiddenChanged(fullPath)
+                ? AssetStatus.HiddenChanged
+                : AssetStatus.None;
+        }
+
+        readonly WorkspaceInfo mWkInfo;
+        readonly Dictionary<string, AssetStatus> mStatusByPathCache =
+            BuildPathDictionary.ForPlatform<AssetStatus>();
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/LocalStatusCache.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/LockStatusCache.cs

@@ -0,0 +1,184 @@
+using System.Collections.Generic;
+
+using Codice;
+using Codice.Client.Commands.WkTree;
+using Codice.Client.Common;
+using Codice.Client.Common.Locks;
+using Codice.Client.Common.Threading;
+using Codice.Client.Common.WkTree;
+using Codice.CM.Common;
+using Codice.CM.Common.Mount;
+using Codice.Utils;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.Items.Locks;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays.Cache
+{
+    internal class LockStatusCache
+    {
+        internal LockStatusCache(
+            WorkspaceInfo wkInfo)
+        {
+            mWkInfo = wkInfo;
+        }
+
+        internal AssetStatus GetStatus(string fullPath)
+        {
+            LockStatusData lockStatusData = GetLockStatusData(fullPath);
+
+            if (lockStatusData == null)
+                return AssetStatus.None;
+
+            return lockStatusData.Status;
+        }
+
+        internal LockStatusData GetLockStatusData(string fullPath)
+        {
+            lock (mLock)
+            {
+                if (mStatusByPathCache == null)
+                {
+                    mStatusByPathCache = BuildPathDictionary.ForPlatform<LockStatusData>();
+
+                    mCurrentCancelToken.Cancel();
+                    mCurrentCancelToken = new CancelToken();
+                    AsyncCalculateStatus(mCurrentCancelToken);
+
+                    return null;
+                }
+
+                LockStatusData result;
+
+                if (mStatusByPathCache.TryGetValue(fullPath, out result))
+                    return result;
+
+                return null;
+            }
+        }
+
+        internal void Clear()
+        {
+            lock (mLock)
+            {
+                mCurrentCancelToken.Cancel();
+
+                mStatusByPathCache = null;
+            }
+        }
+
+        internal void Cancel()
+        {
+            lock (mLock)
+            {
+                mCurrentCancelToken.Cancel();
+            }
+        }
+
+        void AsyncCalculateStatus(CancelToken cancelToken)
+        {
+            Dictionary<string, LockStatusData> statusByPathCache = null;
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    Dictionary<MountPointWithPath, List<WorkspaceTreeNode>> lockCandidates =
+                        new Dictionary<MountPointWithPath, List<WorkspaceTreeNode>>();
+
+                    FillLockCandidates.ForTree(mWkInfo, lockCandidates);
+
+                    if (cancelToken.IsCancelled())
+                        return;
+
+                    Dictionary<WorkspaceTreeNode, LockInfo> lockInfoByNode =
+                        SearchLocks.GetLocksInfo(mWkInfo, lockCandidates);
+
+                    if (cancelToken.IsCancelled())
+                        return;
+
+                    statusByPathCache = BuildStatusByNodeCache.
+                        ForLocks(mWkInfo.ClientPath, lockInfoByNode);
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    if (cancelToken.IsCancelled())
+                        return;
+
+                    if (waiter.Exception != null)
+                    {
+                        ExceptionsHandler.LogException(
+                            "LockStatusCache",
+                            waiter.Exception);
+                        return;
+                    }
+
+                    lock (mLock)
+                    {
+                        mStatusByPathCache = statusByPathCache;
+                    }
+
+                    RepaintEditor.AllWindowsWithOverlays();
+                });
+        }
+
+        static class BuildStatusByNodeCache
+        {
+            internal static Dictionary<string, LockStatusData> ForLocks(
+                string wkPath,
+                Dictionary<WorkspaceTreeNode, LockInfo> lockInfoByNode)
+            {
+                Dictionary<string, LockStatusData> result =
+                    BuildPathDictionary.ForPlatform<LockStatusData>();
+
+                LockOwnerNameResolver nameResolver = new LockOwnerNameResolver();
+
+                foreach (WorkspaceTreeNode node in lockInfoByNode.Keys)
+                {
+                    LockStatusData lockStatusData = BuildLockStatusData(
+                       node, lockInfoByNode[node], nameResolver);
+
+                    string nodeWkPath = WorkspacePath.GetWorkspacePathFromCmPath(
+                        wkPath,
+                        WorkspaceNodeOperations.GetCmPath(node),
+                        PathHelper.GetDirectorySeparatorChar(wkPath));
+
+                    result.Add(nodeWkPath, lockStatusData);
+                }
+
+                return result;
+            }
+
+            static LockStatusData BuildLockStatusData(
+                WorkspaceTreeNode node,
+                LockInfo lockInfo,
+                LockOwnerNameResolver nameResolver)
+            {
+                return new LockStatusData(
+                    GetAssetStatus(node, lockInfo),
+                    nameResolver.GetSeidName(lockInfo.SEIDData),
+                    BranchInfoCache.GetProtectedBranchName(
+                        node.RepSpec, lockInfo.HolderBranchId));
+            }
+
+            static AssetStatus GetAssetStatus(
+                WorkspaceTreeNode node,
+                LockInfo lockInfo)
+            {
+                if (lockInfo.Status == LockInfo.LockStatus.Retained)
+                    return AssetStatus.Retained;
+
+                return CheckWorkspaceTreeNodeStatus.IsCheckedOut(node) ?
+                    AssetStatus.Locked : AssetStatus.LockedRemote;
+            }
+        }
+
+        CancelToken mCurrentCancelToken = new CancelToken();
+
+        Dictionary<string, LockStatusData> mStatusByPathCache;
+
+        readonly WorkspaceInfo mWkInfo;
+
+        static object mLock = new object();
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/LockStatusCache.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/RemoteStatusCache.cs

@@ -0,0 +1,181 @@
+using System.Collections.Generic;
+
+using Codice.Client.Common;
+using Codice.Client.Common.Threading;
+using Codice.CM.Common;
+using Codice.CM.Common.Merge;
+using Codice.CM.Common.Mount;
+using Codice.CM.Common.Partial;
+using Codice.CM.Common.Update.Partial;
+using Codice.Utils;
+using GluonGui.WorkspaceWindow.Views;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays.Cache
+{
+    internal class RemoteStatusCache
+    {
+        internal RemoteStatusCache(
+            WorkspaceInfo wkInfo,
+            bool isGluonMode)
+        {
+            mWkInfo = wkInfo;
+            mIsGluonMode = isGluonMode;
+        }
+
+        internal AssetStatus GetStatus(string fullPath)
+        {
+            if (!mIsGluonMode)
+                return AssetStatus.UpToDate;
+
+            lock(mLock)
+            {
+                if (mStatusByPathCache == null)
+                {
+                    mStatusByPathCache = BuildPathDictionary.ForPlatform<AssetStatus>();
+
+                    mCurrentCancelToken.Cancel();
+                    mCurrentCancelToken = new CancelToken();
+                    AsyncCalculateStatus(mCurrentCancelToken);
+
+                    return AssetStatus.UpToDate;
+                }
+
+                AssetStatus result;
+                if (mStatusByPathCache.TryGetValue(fullPath, out result))
+                    return result;
+
+                return AssetStatus.UpToDate;
+            }
+        }
+
+        internal void Clear()
+        {
+            lock (mLock)
+            {
+                mCurrentCancelToken.Cancel();
+                mStatusByPathCache = null;
+            }
+        }
+
+        internal void Cancel()
+        {
+            lock (mLock)
+            {
+                mCurrentCancelToken.Cancel();
+            }
+        }
+
+        void AsyncCalculateStatus(CancelToken cancelToken)
+        {
+            Dictionary<string, AssetStatus> statusByPathCache = null;
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    OutOfDateItems outOfDateItems =
+                        OutOfDateUpdater.CalculateOutOfDateItems(
+                            mWkInfo, new List<ErrorMessage>(),
+                            OutOfDateCalculator.Options.IsIncomingChanges);
+
+                    if (cancelToken.IsCancelled())
+                        return;
+
+                    statusByPathCache = BuildStatusByPathCache.
+                        ForOutOfDateItems(outOfDateItems, mWkInfo.ClientPath);
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    if (cancelToken.IsCancelled())
+                        return;
+
+                    if (waiter.Exception != null)
+                    {
+                        ExceptionsHandler.LogException(
+                            "RemoteStatusCache",
+                            waiter.Exception);
+                        return;
+                    }
+
+                    lock (mLock)
+                    {
+                        mStatusByPathCache = statusByPathCache;
+                    }
+
+                    RepaintEditor.AllWindowsWithOverlays();
+                });
+        }
+
+        static class BuildStatusByPathCache
+        {
+            internal static Dictionary<string, AssetStatus> ForOutOfDateItems(
+                OutOfDateItems outOfDateItems,
+                string wkPath)
+            {
+                Dictionary<string, AssetStatus> result =
+                    BuildPathDictionary.ForPlatform<AssetStatus>();
+
+                if (outOfDateItems == null)
+                    return result;
+
+                foreach (OutOfDateItemsByMount diffs in
+                    outOfDateItems.GetOutOfDateItemsByMountList(PathHelper.GetPathSorter()))
+                {
+                    foreach (Difference diff in diffs.Changed)
+                    {
+                        if (diff is DiffXlinkChanged)
+                            continue;
+
+                        string path = GetPathForDiff(wkPath, diffs.Mount, diff.Path);
+                        result.Add(path, AssetStatus.OutOfDate);
+                    }
+
+                    foreach (Difference diff in diffs.Deleted)
+                    {
+                        string path = GetPathForDiff(wkPath, diffs.Mount, diff.Path);
+                        result.Add(path, AssetStatus.DeletedOnServer);
+                    }
+                }
+
+                foreach (GluonFileConflict fileConflict in
+                    outOfDateItems.GetFileConflicts())
+                {
+                    string path = GetPathForConflict(wkPath, fileConflict.CmPath);
+                    result.Add(path, AssetStatus.Conflicted);
+                }
+
+                return result;
+            }
+
+            static string GetPathForDiff(
+                string wkPath,
+                MountPointWithPath mountPoint,
+                string cmSubPath)
+            {
+                return WorkspacePath.GetWorkspacePathFromCmPath(
+                    wkPath,
+                    WorkspacePath.ComposeMountPath(mountPoint.MountPath, cmSubPath),
+                    PathHelper.GetDirectorySeparatorChar(wkPath));
+            }
+
+            static string GetPathForConflict(
+                string wkPath,
+                string cmPath)
+            {
+                return WorkspacePath.GetWorkspacePathFromCmPath(
+                    wkPath, cmPath,
+                    PathHelper.GetDirectorySeparatorChar(wkPath));
+            }
+        }
+
+        CancelToken mCurrentCancelToken = new CancelToken();
+
+        Dictionary<string, AssetStatus> mStatusByPathCache;
+
+        readonly bool mIsGluonMode;
+        readonly WorkspaceInfo mWkInfo;
+
+        static object mLock = new object();
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/Cache/RemoteStatusCache.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawAssetOverlayIcon.cs

@@ -0,0 +1,86 @@
+using UnityEngine;
+
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays
+{
+    internal static class DrawAssetOverlayIcon
+    {
+        internal static void ForStatus(
+            Rect selectionRect,
+            AssetStatus status,
+            string tooltipText)
+        {
+            Texture overlayIcon = GetOverlayIcon(status);
+
+            if (overlayIcon == null)
+                return;
+
+            Rect overlayRect = GetOverlayRect.ForSelectionRect(selectionRect);
+
+            GUI.DrawTexture(overlayRect, overlayIcon, ScaleMode.ScaleToFit);
+
+            Rect tooltipRect = GetTooltipRect(selectionRect, overlayRect);
+
+            GUI.Label(tooltipRect, new GUIContent(string.Empty, tooltipText));
+        }
+
+        internal static Texture GetOverlayIcon(AssetStatus assetStatus)
+        {
+            if (ClassifyAssetStatus.IsPrivate(assetStatus))
+                return Images.GetPrivateOverlayIcon();
+
+            if (ClassifyAssetStatus.IsIgnored(assetStatus))
+                return Images.GetIgnoredOverlayIcon();
+
+            if (ClassifyAssetStatus.IsAdded(assetStatus))
+                return Images.GetAddedOverlayIcon();
+
+            if (ClassifyAssetStatus.IsConflicted(assetStatus))
+                return Images.GetConflictedOverlayIcon();
+
+            if (ClassifyAssetStatus.IsDeletedOnServer(assetStatus))
+                return Images.GetDeletedRemoteOverlayIcon();
+
+            if (ClassifyAssetStatus.IsLockedRemote(assetStatus))
+                return Images.GetLockedRemoteOverlayIcon();
+
+            if (ClassifyAssetStatus.IsOutOfDate(assetStatus))
+                return Images.GetOutOfSyncOverlayIcon();
+
+            if (ClassifyAssetStatus.IsLocked(assetStatus))
+                return Images.GetLockedLocalOverlayIcon();
+
+            if (ClassifyAssetStatus.IsRetained(assetStatus))
+                return Images.GetRetainedOverlayIcon();
+
+            if (ClassifyAssetStatus.IsCheckedOut(assetStatus) ||
+                ClassifyAssetStatus.IsChanged(assetStatus) ||
+                ClassifyAssetStatus.ContainsChanges(assetStatus))
+                return Images.GetCheckedOutOverlayIcon();
+
+            return null;
+        }
+
+        static Rect Inflate(Rect rect, float width, float height)
+        {
+            return new Rect(
+                rect.x - width,
+                rect.y - height,
+                rect.width + 2f * width,
+                rect.height + 2f * height);
+        }
+
+        static Rect GetTooltipRect(
+            Rect selectionRect,
+            Rect overlayRect)
+        {
+            if (selectionRect.width > selectionRect.height)
+            {
+                return overlayRect;
+            }
+
+            return Inflate(overlayRect, 3f, 3f);
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawAssetOverlayIcon.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawHierarchyOverlay.cs

@@ -0,0 +1,210 @@
+using System;
+
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+using Codice.Client.Common.Threading;
+using Codice.LogWrapper;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+using Object = UnityEngine.Object;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays
+{
+    internal static class DrawHierarchyOverlay
+    {
+        internal interface IGetAssetPathFromInstance
+        {
+            bool TryGetAssetPath(int instanceID, out string assetPath);
+        }
+
+        internal static IGetAssetPathFromInstance GetSubSceneAssetPath;
+
+        internal static void Enable(
+            string wkPath,
+            IAssetStatusCache assetStatusCache)
+        {
+            if (mIsEnabled)
+                return;
+
+            mLog.Debug("Enable");
+
+            mWkPath = wkPath;
+            mAssetStatusCache = assetStatusCache;
+
+            mIsEnabled = true;
+
+#if UNITY_6000_4_OR_NEWER
+            EditorApplication.hierarchyWindowItemByEntityIdOnGUI += OnHierarchyGUIByEntityId;
+#else
+            EditorApplication.hierarchyWindowItemOnGUI += OnHierarchyGUI;
+#endif
+
+            RepaintEditor.HierarchyWindow();
+        }
+
+        internal static void Disable()
+        {
+            mLog.Debug("Disable");
+
+            mIsEnabled = false;
+
+#if UNITY_6000_4_OR_NEWER
+            EditorApplication.hierarchyWindowItemByEntityIdOnGUI -= OnHierarchyGUIByEntityId;
+#else
+            EditorApplication.hierarchyWindowItemOnGUI -= OnHierarchyGUI;
+#endif
+
+            RepaintEditor.HierarchyWindow();
+
+            mWkPath = null;
+            mAssetStatusCache = null;
+        }
+
+#if UNITY_6000_4_OR_NEWER
+        static void OnHierarchyGUIByEntityId(EntityId entityId, Rect selectionRect)
+        {
+            OnHierarchyGUI((int)entityId.GetRawData(), selectionRect);
+        }
+#endif
+
+        static void OnHierarchyGUI(int instanceID, Rect selectionRect)
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            try
+            {
+                string assetPath = GetAssetPathFromInstanceID(instanceID);
+
+                if (assetPath == null)
+                    return;
+
+                string assetFullPath = AssetsPath.GetFullPathUnderWorkspace.ForAsset(mWkPath, assetPath);
+
+                if (assetFullPath == null)
+                    return;
+
+                DrawOverlayForAsset(assetFullPath, selectionRect, mAssetStatusCache);
+            }
+            catch (Exception ex)
+            {
+                ExceptionsHandler.LogException(typeof(DrawHierarchyOverlay).Name, ex);
+            }
+        }
+
+        static string GetAssetPathFromInstanceID(int instanceID)
+        {
+            string sceneAssetPath;
+            if (TryGetAssetPathForScene(instanceID, out sceneAssetPath))
+            {
+                return sceneAssetPath;
+            }
+
+            string subSceneAssetPath;
+            if (TryGetAssetPathForSubScene(instanceID, out subSceneAssetPath))
+            {
+                return subSceneAssetPath;
+            }
+
+            string prefabAssetPath;
+            if (TryGetAssetPathForPrefab(instanceID, out prefabAssetPath))
+            {
+                return prefabAssetPath;
+            }
+
+            return null;
+        }
+
+        static bool TryGetAssetPathForScene(int instanceID, out string assetPath)
+        {
+            assetPath = null;
+
+            if (FindUnityObject.ForInstanceID(instanceID) != null)
+                return false;
+
+            assetPath = FindScenePathForHandle(instanceID);
+
+            return assetPath != null;
+        }
+
+        static string FindScenePathForHandle(int sceneHandle)
+        {
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+
+#if UNITY_6000_4_OR_NEWER
+                if (scene.handle == SceneHandle.FromRawData((ulong)sceneHandle) && scene.path != null)
+#else
+                if (scene.handle == sceneHandle && scene.path != null)
+#endif
+                {
+                    return scene.path;
+                }
+            }
+
+            return null;
+        }
+
+        static bool TryGetAssetPathForSubScene(int instanceID, out string assetPath)
+        {
+            assetPath = null;
+
+            string subSceneAssetPath;
+            if (GetSubSceneAssetPath != null &&
+                GetSubSceneAssetPath.TryGetAssetPath(instanceID, out subSceneAssetPath))
+            {
+                assetPath = subSceneAssetPath;
+            }
+
+            return assetPath != null;
+        }
+
+        static bool TryGetAssetPathForPrefab(int instanceID, out string assetPath)
+        {
+            assetPath = null;
+
+            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+
+            if (prefabStage == null)
+                return false;
+
+            Object hierarchyObject = FindUnityObject.ForInstanceID(instanceID);
+
+            if (hierarchyObject == null)
+                return false;
+
+            if (prefabStage.prefabContentsRoot == hierarchyObject)
+                assetPath = prefabStage.assetPath;
+
+            return assetPath != null;
+        }
+
+        static void DrawOverlayForAsset(
+            string assetFullPath,
+            Rect selectionRect,
+            IAssetStatusCache assetStatusCache)
+        {
+            AssetStatus assetStatus = assetStatusCache.GetStatus(assetFullPath);
+
+            string tooltipText = AssetOverlay.GetTooltipText(
+                assetStatus,
+                assetStatusCache.GetLockStatusData(assetFullPath));
+
+            DrawAssetOverlayIcon.ForStatus(
+                selectionRect,
+                assetStatus,
+                tooltipText);
+        }
+
+        static bool mIsEnabled;
+        static IAssetStatusCache mAssetStatusCache;
+        static string mWkPath;
+
+        static readonly ILog mLog = PlasticApp.GetLogger("DrawHierarchyOverlay");
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawHierarchyOverlay.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawProjectOverlay.cs

@@ -0,0 +1,87 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common.Threading;
+using Codice.LogWrapper;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+using Unity.PlasticSCM.Editor.AssetUtils;
+
+namespace Unity.PlasticSCM.Editor.AssetsOverlays
+{
+    internal static class DrawProjectOverlay
+    {
+        internal static void Enable(
+            string wkPath,
+            IAssetStatusCache assetStatusCache)
+        {
+            if (mIsEnabled)
+                return;
+
+            mLog.Debug("Enable");
+
+            mWkPath = wkPath;
+            mAssetStatusCache = assetStatusCache;
+
+            mIsEnabled = true;
+
+            EditorApplication.projectWindowItemOnGUI += OnProjectWindowItemGUI;
+
+            RepaintEditor.ProjectWindow();
+        }
+
+        internal static void Disable()
+        {
+            mLog.Debug("Disable");
+
+            mIsEnabled = false;
+
+            EditorApplication.projectWindowItemOnGUI -= OnProjectWindowItemGUI;
+
+            RepaintEditor.ProjectWindow();
+
+            mWkPath = null;
+            mAssetStatusCache = null;
+        }
+
+        static void OnProjectWindowItemGUI(string guid, Rect selectionRect)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(guid))
+                    return;
+
+                if (Event.current.type != EventType.Repaint)
+                    return;
+
+                string fullPath = AssetsPath.GetFullPathUnderWorkspace.ForGuid(mWkPath, guid);
+
+                if (fullPath == null)
+                    return;
+
+                AssetStatus assetStatus = mAssetStatusCache.GetStatus(fullPath);
+
+                string tooltipText = AssetOverlay.GetTooltipText(
+                    assetStatus,
+                    mAssetStatusCache.GetLockStatusData(fullPath));
+
+                DrawAssetOverlayIcon.ForStatus(
+                    selectionRect,
+                    assetStatus,
+                    tooltipText);
+            }
+            catch (Exception ex)
+            {
+                ExceptionsHandler.LogException(typeof(DrawProjectOverlay).Name, ex);
+            }
+        }
+
+        static bool mIsEnabled;
+        static IAssetStatusCache mAssetStatusCache;
+        static string mWkPath;
+
+        static readonly ILog mLog = PlasticApp.GetLogger("DrawProjectOverlay");
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/AssetOverlays/DrawProjectOverlay.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images.meta

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

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/buttonssosigninemail.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: d24e7e0b75e1a244bb9687d6fd4315ef
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/buttonssosigninemail@2x.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: ddf2e76e8a1f88f46ae1e42277850b48
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/buttonssosigningoogle.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: f09eae8c0ea04254b90c5386a034a225
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/buttonssosigninunity.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: f9161c6c9e06dc445ada3ee16d991f90
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/buttonssosigninunity@2x.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: ee8ce5cd9c0883f4182b5cfd43cfd7fe
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_buttonssosigninemail.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 3086d66a563317b40a20a20da2c64ac0
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_buttonssosigninemail@2x.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 144aa74618b85974a9a50f612c2fa8fd
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_hideversioncontrol.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: ec597fbbebec64e4f8725c31ce52fdb7
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_hideversioncontrol@2x.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: 5de67bf0a3c601f4bab93b4fd3314ab1
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconaddedlocal.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 0c6a2a64ca9f9c946a7dbbd1674cf5bd
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconaddedlocal@2x.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 02800fb9cff14da47a04572790384d8b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconaddedoverlay.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 73d124bf77e463c45942d14136745d9f
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconaddedoverlay@2x.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: a6fbd5a181bc51e42a61a73fe8d727c8
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbranch.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: c1516142c0a669b42aecce30a3459017
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbranch@2x.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: 267a89f787a621e4290fbff7a5442750
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbranches.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 612c5e166a121e3449dad067fbdc37a4
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbranches@2x.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 874d8401331ede14087e8d8d486ddda6
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbrex.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: d44f9c7a4044e1845b5b3627ba32fb10
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconbrex@2x.png.meta

@@ -0,0 +1,123 @@
+fileFormatVersion: 2
+guid: 9b76c79563c3a274aa48b0dbdf009693
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconchangesets.png.meta

@@ -0,0 +1,111 @@
+fileFormatVersion: 2
+guid: 4da398eacd0c045bebf576a9f11339b0
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconchangesets@2x.png.meta

@@ -0,0 +1,111 @@
+fileFormatVersion: 2
+guid: b76c20add7d3d4f79afcbafeaa12e974
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@2.11.3/Editor/Assets/Images/d_iconcheckedoutlocaloverlay.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: bb1928aff4fd4cf44af1f629dc14ef9b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: XboxOne
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: