Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshPreviewTool/MeshPreviewTool.cs

@@ -0,0 +1,331 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class MeshPreviewTool : BaseTool
+    {
+        [SerializeField]
+        private Material m_Material;
+        private List<SpriteCache> m_Sprites;
+        private IMeshPreviewBehaviour m_DefaultPreviewBehaviour = new DefaultPreviewBehaviour();
+
+        public IMeshPreviewBehaviour previewBehaviourOverride { get; set; }
+        public override IMeshPreviewBehaviour previewBehaviour
+        {
+            get
+            {
+                if (previewBehaviourOverride != null)
+                    return previewBehaviourOverride;
+
+                return m_DefaultPreviewBehaviour;
+            }
+        }
+
+        internal override void OnCreate()
+        {
+            m_Material = new Material(Shader.Find("Hidden/SkinningModule-GUITextureClip"));
+            m_Material.hideFlags = HideFlags.DontSave;
+        }
+
+        internal override void OnDestroy()
+        {
+            base.OnDestroy();
+
+            Debug.Assert(m_Material != null);
+
+            DestroyImmediate(m_Material);
+        }
+
+        protected override void OnActivate()
+        {
+            m_Sprites = new List<SpriteCache>(skinningCache.GetSprites());
+
+            DirtyMeshesAll();
+
+            skinningCache.events.meshChanged.AddListener(MeshChanged);
+            skinningCache.events.characterPartChanged.AddListener(CharacterPartChanged);
+            skinningCache.events.skeletonPreviewPoseChanged.AddListener(SkeletonChanged);
+            skinningCache.events.skeletonBindPoseChanged.AddListener(SkeletonChanged);
+            skinningCache.events.skinningModeChanged.AddListener(SkinningModuleModeChanged);
+        }
+
+        protected override void OnDeactivate()
+        {
+            skinningCache.events.meshChanged.RemoveListener(MeshChanged);
+            skinningCache.events.skeletonPreviewPoseChanged.RemoveListener(SkeletonChanged);
+            skinningCache.events.skeletonBindPoseChanged.RemoveListener(SkeletonChanged);
+            skinningCache.events.skinningModeChanged.RemoveListener(SkinningModuleModeChanged);
+        }
+
+        protected override void OnGUI()
+        {
+            Prepare();
+
+            if (Event.current.type == EventType.Repaint)
+            {
+                //DrawDefaultSpriteMeshes();
+                DrawSpriteMeshes();
+            }
+        }
+
+        public void DrawOverlay()
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            if (skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                foreach (var sprite in m_Sprites)
+                {
+                    if (previewBehaviour.Overlay(sprite))
+                        DrawSpriteMesh(sprite);
+                }
+            }
+            else
+            {
+                var character = skinningCache.character;
+                Debug.Assert(character != null);
+
+                var parts = character.parts;
+                foreach (var part in parts)
+                {
+                    if (part.isVisible && previewBehaviour.Overlay(part.sprite))
+                        DrawSpriteMesh(part.sprite);
+                }
+            }
+        }
+
+        public void OverlayWireframe()
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            foreach (var sprite in m_Sprites)
+                if (previewBehaviour.OverlayWireframe(sprite))
+                    DrawWireframe(sprite);
+        }
+
+        private void CharacterPartChanged(CharacterPartCache characterPart)
+        {
+            var meshPreview = characterPart.sprite.GetMeshPreview();
+            Debug.Assert(meshPreview != null);
+            meshPreview.SetSkinningDirty();
+        }
+
+        private void MeshChanged(MeshCache mesh)
+        {
+            var meshPreview = mesh.sprite.GetMeshPreview();
+            Debug.Assert(meshPreview != null);
+            meshPreview.SetMeshDirty();
+        }
+
+        private void SkeletonChanged(SkeletonCache skeleton)
+        {
+            DirtySkinningAll();
+        }
+
+        private void SkinningModuleModeChanged(SkinningMode mode)
+        {
+            DirtyMeshesAll();
+        }
+
+        private void DirtyMeshesAll()
+        {
+            foreach (var sprite in m_Sprites)
+            {
+                var meshPreview = sprite.GetMeshPreview();
+
+                if (meshPreview != null)
+                    meshPreview.SetMeshDirty();
+            }
+        }
+
+        private void DirtySkinningAll()
+        {
+            foreach (var sprite in m_Sprites)
+            {
+                var meshPreview = sprite.GetMeshPreview();
+                Debug.Assert(meshPreview != null);
+                meshPreview.SetSkinningDirty();
+            }
+        }
+
+        private void Prepare()
+        {
+            foreach (var sprite in m_Sprites)
+            {
+                var meshPreview = sprite.GetMeshPreview();
+                Debug.Assert(meshPreview != null);
+                meshPreview.enableSkinning = true;
+                meshPreview.Prepare();
+            }
+        }
+
+        private void DrawDefaultSpriteMeshes()
+        {
+            Debug.Assert(Event.current.type == EventType.Repaint);
+
+            if (skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                foreach (var sprite in m_Sprites)
+                    DrawDefaultSpriteMesh(sprite);
+            }
+            else
+            {
+                var character = skinningCache.character;
+                Debug.Assert(character != null);
+
+                var parts = character.parts;
+                foreach (var part in parts)
+                {
+                    if (part.isVisible)
+                        DrawDefaultSpriteMesh(part.sprite);
+                }
+            }
+        }
+
+        private void DrawDefaultSpriteMesh(SpriteCache sprite)
+        {
+            Debug.Assert(m_Material != null);
+
+            var meshPreview = sprite.GetMeshPreview();
+            var meshCache = sprite.GetMesh();
+            var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+
+            Debug.Assert(meshPreview != null);
+
+            if (meshPreview.canSkin == false || skeleton.isPosePreview == false)
+            {
+                m_Material.mainTexture = meshCache.textureDataProvider.texture;
+                m_Material.SetFloat("_Opacity", 1f);
+                m_Material.SetFloat("_VertexColorBlend", 0f);
+                m_Material.color = new Color(1f, 1f, 1f, 1f);
+
+                DrawingUtility.DrawMesh(meshPreview.defaultMesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
+            }
+        }
+
+        private void DrawSpriteMeshes()
+        {
+            Debug.Assert(Event.current.type == EventType.Repaint);
+
+            if (skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                foreach (var sprite in m_Sprites)
+                {
+                    if (previewBehaviour.Overlay(sprite))
+                        continue;
+
+                    DrawSpriteMesh(sprite);
+                }
+            }
+            else
+            {
+                var character = skinningCache.character;
+                Debug.Assert(character != null);
+
+                var parts = character.parts;
+                var selected = skinningCache.selectedSprite;
+                var selectedVisible = false;
+                foreach (var part in parts)
+                {
+                    if (previewBehaviour.Overlay(part.sprite))
+                        continue;
+
+                    if (part.sprite == selected)
+                        selectedVisible = part.isVisible;
+                    else if (part.isVisible)
+                        DrawSpriteMesh(part.sprite);
+                }
+
+                if (selectedVisible && selected != null)
+                    DrawSpriteMesh(selected);
+            }
+        }
+
+        private void DrawSpriteMesh(SpriteCache sprite)
+        {
+            var weightMapOpacity = previewBehaviour.GetWeightMapOpacity(sprite);
+            DrawSpriteMesh(sprite, weightMapOpacity);
+
+            if (previewBehaviour.DrawWireframe(sprite))
+                DrawWireframe(sprite);
+        }
+
+        private void DrawSpriteMesh(SpriteCache sprite, float weightMapOpacity)
+        {
+            Debug.Assert(m_Material != null);
+
+            var meshPreview = sprite.GetMeshPreview();
+            var meshCache = sprite.GetMesh();
+
+            Debug.Assert(meshPreview != null);
+
+            if (meshPreview.mesh == null || meshPreview.mesh.vertexCount == 0)
+            {
+                DrawDefaultSpriteMesh(sprite);
+            }
+            else
+            {
+                m_Material.mainTexture = meshCache.textureDataProvider.texture;
+                m_Material.SetFloat("_Opacity", 1f);
+                m_Material.SetFloat("_VertexColorBlend", weightMapOpacity);
+
+                m_Material.color = Color.white;
+
+                DrawingUtility.DrawMesh(meshPreview.mesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
+            }
+        }
+
+        private void DrawSelectedSpriteWeightMap()
+        {
+            var selectedSprite = skinningCache.selectedSprite;
+
+            if (selectedSprite != null)
+            {
+                var opacity = GetWeightOpacityFromCurrentTool();
+
+                if (opacity > 0f)
+                    DrawSpriteMesh(selectedSprite, opacity);
+            }
+        }
+
+        private float GetWeightOpacityFromCurrentTool()
+        {
+            return IsWeightTool() ? VisibilityToolSettings.meshOpacity : 0f;
+        }
+
+        private bool IsWeightTool()
+        {
+            var currentTool = skinningCache.selectedTool;
+
+            if (currentTool == skinningCache.GetTool(Tools.WeightSlider) ||
+                currentTool == skinningCache.GetTool(Tools.WeightBrush) ||
+                currentTool == skinningCache.GetTool(Tools.BoneInfluence) ||
+                currentTool == skinningCache.GetTool(Tools.GenerateWeights))
+                return true;
+
+            return false;
+        }
+
+        private void DrawWireframe(SpriteCache sprite)
+        {
+            Debug.Assert(Event.current.type == EventType.Repaint);
+            Debug.Assert(sprite != null);
+
+            var meshPreview = sprite.GetMeshPreview();
+            Debug.Assert(meshPreview != null);
+
+            m_Material.mainTexture = null;
+            m_Material.SetFloat("_Opacity", 0.35f);
+            m_Material.SetFloat("_VertexColorBlend", 0f);
+            m_Material.color = Color.white;
+
+            GL.wireframe = true;
+            DrawingUtility.DrawMesh(meshPreview.mesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
+            GL.wireframe = false;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshPreviewTool/MeshPreviewTool.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshTool/MeshTool.cs

@@ -0,0 +1,186 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal partial class MeshTool : BaseTool
+    {
+        private MeshCache m_Mesh;
+        private ISelection<int> m_SelectionOverride;
+        private SpriteMeshController m_SpriteMeshController;
+        private SpriteMeshView m_SpriteMeshView;
+        private RectSelectionTool<int> m_RectSelectionTool = new RectSelectionTool<int>();
+        private RectVertexSelector m_RectVertexSelector = new RectVertexSelector();
+        private UnselectTool<int> m_UnselectTool = new UnselectTool<int>();
+        private ITriangulator m_Triangulator;
+
+        public MeshCache mesh
+        {
+            get { return m_Mesh; }
+        }
+
+        public SpriteMeshViewMode mode
+        {
+            get { return m_SpriteMeshView.mode; }
+            set { m_SpriteMeshView.mode = value; }
+        }
+
+        public bool disable
+        {
+            get { return m_SpriteMeshController.disable; }
+            set { m_SpriteMeshController.disable = value; }
+        }
+
+        public ISelection<int> selectionOverride
+        {
+            get { return m_SelectionOverride; }
+            set { m_SelectionOverride = value; }
+        }
+
+        public override int defaultControlID
+        {
+            get
+            {
+                if (m_Mesh == null)
+                    return 0;
+
+                return m_RectSelectionTool.controlID;
+            }
+        }
+
+        private ISelection<int> selection
+        {
+            get
+            {
+                if(selectionOverride != null)
+                    return selectionOverride;
+                return skinningCache.vertexSelection;
+            }
+        }
+
+        internal override void OnCreate()
+        {
+            m_SpriteMeshController = new SpriteMeshController();
+            m_SpriteMeshView = new SpriteMeshView(new GUIWrapper());
+            m_Triangulator = new Triangulator();
+        }
+
+        protected override void OnActivate()
+        {
+            m_SpriteMeshController.disable = false;
+            m_SelectionOverride = null;
+
+            SetupSprite(skinningCache.selectedSprite);
+
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSelectedSpriteChanged);
+        }
+
+        protected override void OnDeactivate()
+        {
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSelectedSpriteChanged);
+        }
+
+        private void OnSelectedSpriteChanged(SpriteCache sprite)
+        {
+            SetupSprite(sprite);
+        }
+
+        internal void SetupSprite(SpriteCache sprite)
+        {
+            var mesh = sprite.GetMesh();
+
+            if (m_Mesh != null 
+                && m_Mesh != mesh 
+                && selection.Count > 0)
+                selection.Clear();
+
+            m_Mesh = mesh;
+            m_SpriteMeshController.spriteMeshData = m_Mesh;
+        }
+
+        private void SetupGUI()
+        {
+            m_SpriteMeshController.spriteMeshView = m_SpriteMeshView;
+            m_SpriteMeshController.triangulator = m_Triangulator;
+            m_SpriteMeshController.cacheUndo = skinningCache;
+            m_RectSelectionTool.cacheUndo = skinningCache;
+            m_RectSelectionTool.rectSelector = m_RectVertexSelector;
+            m_RectVertexSelector.selection = selection;
+            m_UnselectTool.cacheUndo = skinningCache;
+            m_UnselectTool.selection = selection;
+
+            m_SpriteMeshController.frame = new Rect(Vector2.zero, m_Mesh.sprite.textureRect.size);
+            m_SpriteMeshController.selection = selection;
+            m_SpriteMeshView.defaultControlID = defaultControlID;
+            m_RectVertexSelector.spriteMeshData = m_Mesh;
+        }
+
+        protected override void OnGUI()
+        {
+            if (m_Mesh == null)
+                return;
+
+            SetupGUI();
+
+            var handlesMatrix = Handles.matrix;
+            Handles.matrix *= m_Mesh.sprite.GetLocalToWorldMatrixFromMode();
+
+            BeginPositionOverride();
+
+            EditorGUI.BeginChangeCheck();
+
+            var guiEnabled = GUI.enabled;
+            var moveAction = m_SpriteMeshController.spriteMeshView.IsActionHot(MeshEditorAction.MoveEdge) || m_SpriteMeshController.spriteMeshView.IsActionHot(MeshEditorAction.MoveVertex);
+            GUI.enabled = (!skinningCache.IsOnVisualElement() && guiEnabled) || moveAction;
+            m_SpriteMeshController.OnGUI();
+            GUI.enabled = guiEnabled;
+
+            if (EditorGUI.EndChangeCheck())
+                UpdateMesh();
+
+            m_RectSelectionTool.OnGUI();
+            m_UnselectTool.OnGUI();
+
+            Handles.matrix = handlesMatrix;
+
+            EndPositionOverride();
+        }
+
+        public void BeginPositionOverride()
+        {
+            if(m_Mesh != null)
+            {
+                m_Mesh.vertexPositionOverride = null;
+
+                var skeleton = skinningCache.GetEffectiveSkeleton(m_Mesh.sprite);
+
+                Debug.Assert(skeleton != null);
+
+                if (skeleton.isPosePreview)
+                    m_Mesh.vertexPositionOverride = m_Mesh.sprite.GetMeshPreview().vertices;
+            }
+        }
+
+        public void EndPositionOverride()
+        {
+            if(m_Mesh != null)
+                m_Mesh.vertexPositionOverride = null;
+        }
+
+        public void UpdateWeights()
+        {
+            InvokeMeshChanged();
+        }
+
+        public void UpdateMesh()
+        {
+            InvokeMeshChanged();
+        }
+
+        private void InvokeMeshChanged()
+        {
+            if(m_Mesh != null)
+                skinningCache.events.meshChanged.Invoke(m_Mesh);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightPainterTool.cs

@@ -0,0 +1,389 @@
+using UnityEngine;
+using UnityEditor.U2D.Layout;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal enum WeightPainterMode
+    {
+        Brush,
+        Slider
+    }
+
+    internal class WeightPainterTool : MeshToolWrapper
+    {
+        private WeightPainterPanel m_WeightPainterPanel;
+        private WeightEditor m_WeightEditor = new WeightEditor();
+        private Brush m_Brush = new Brush(new GUIWrapper());
+        private ISelection<int> m_BrushSelection = new IndexedSelection();
+        private CircleVertexSelector m_CircleVertexSelector = new CircleVertexSelector();
+
+        public WeightPainterMode paintMode
+        {
+            get { return m_WeightPainterPanel.paintMode; }
+            set { m_WeightPainterPanel.paintMode = value; }
+        }
+
+        public override int defaultControlID
+        {
+            get { return m_Brush.controlID; }
+        }
+
+        internal override void OnCreate()
+        {
+            m_WeightEditor.cacheUndo = skinningCache;
+
+            m_Brush.onMove += (brush) =>
+            {
+                UpdateBrushSelection(brush);
+            };
+            m_Brush.onRepaint += (brush) =>
+            {
+                DrawBrush(brush);
+            };
+            m_Brush.onSize += (brush) =>
+            {
+                UpdateBrushSelection(brush);
+                m_WeightPainterPanel.size = Mathf.RoundToInt(brush.size);
+            };
+            m_Brush.onStrokeBegin += (brush) =>
+            {
+                UpdateBrushSelection(brush);
+                EditStart(m_BrushSelection, true);
+            };
+            m_Brush.onStrokeDelta += (brush) =>
+            {
+                if (m_BrushSelection.Count > 0)
+                    meshTool.UpdateWeights();
+            };
+            m_Brush.onStrokeStep += (brush) =>
+            {
+                UpdateBrushSelection(brush);
+
+                var hardness = brush.hardness / 100f;
+
+                if (EditorGUI.actionKey)
+                    hardness *= -1f;
+
+                EditWeights(hardness, false);
+            };
+            m_Brush.onStrokeEnd += (brush) =>
+            {
+                EditEnd();
+            };
+        }
+
+        public string panelTitle
+        {
+            set { m_WeightPainterPanel.title = value; }
+        }
+
+        protected override void OnActivate()
+        {
+            base.OnActivate();
+            m_WeightPainterPanel.SetHiddenFromLayout(false);
+
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSelectedSpriteChanged);
+            skinningCache.events.skinningModeChanged.AddListener(OnSkinningModeChanged);
+            skinningCache.events.boneSelectionChanged.AddListener(OnBoneSelectionChanged);
+
+            m_Brush.size = skinningCache.brushSize;
+            m_Brush.hardness = skinningCache.brushHardness;
+            m_Brush.step = skinningCache.brushStep;
+            m_WeightPainterPanel.size = (int) m_Brush.size;
+            m_WeightPainterPanel.hardness = (int) m_Brush.hardness;
+            m_WeightPainterPanel.step = (int) m_Brush.step;
+
+            UpdatePanel();
+        }
+
+        protected override void OnDeactivate()
+        {
+            base.OnDeactivate();
+
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSelectedSpriteChanged);
+            skinningCache.events.skinningModeChanged.RemoveListener(OnSkinningModeChanged);
+            skinningCache.events.boneSelectionChanged.RemoveListener(OnBoneSelectionChanged);
+
+            m_WeightPainterPanel.SetHiddenFromLayout(true);
+        }
+
+        private void OnBoneSelectionChanged()
+        {
+            UpdateSelectedBone();
+        }
+
+        private void OnSelectedSpriteChanged(SpriteCache sprite)
+        {
+            UpdatePanel();
+        }
+
+        private void OnSkinningModeChanged(SkinningMode mode)
+        {
+            UpdatePanel();
+        }
+
+        private string[] GetSkeletonBonesNames()
+        {
+            var names = new List<string>() { WeightPainterPanel.kNone };
+            var skeleton = skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+
+            if (skeleton != null)
+                names.AddRange(GetUniqueBoneNames(skeleton.bones, skeleton));
+
+            return names.ToArray();
+        }
+
+        private string[] GetMeshBoneNames()
+        {
+            var mesh = meshTool.mesh;
+            var skeleton = skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+
+            if (mesh != null && skeleton != null)
+            {
+                var bones = meshTool.mesh.bones.ToSpriteSheetIfNeeded();
+                return GetUniqueBoneNames(bones, skeleton);
+            }
+
+            return new string[0];
+        }
+
+        private string[] GetUniqueBoneNames(BoneCache[] bones, SkeletonCache skeleton)
+        {
+            return Array.ConvertAll(bones, b => skeleton.GetUniqueName(b));
+        }
+
+        private void UpdatePanel()
+        {
+            m_WeightPainterPanel.SetActive(skinningCache.selectedSprite != null);
+            m_WeightPainterPanel.UpdateWeightInspector(meshTool.mesh, GetMeshBoneNames(), skinningCache.vertexSelection, skinningCache);
+            m_WeightPainterPanel.UpdatePanel(GetSkeletonBonesNames());
+            UpdateSelectedBone();
+        }
+
+        private void UpdateSelectedBone()
+        {
+            var boneName = WeightPainterPanel.kNone;
+            var bone = skinningCache.skeletonSelection.activeElement.ToSpriteSheetIfNeeded();
+            var skeleton = skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+
+            if (skeleton != null && skeleton.Contains(bone))
+                boneName = skeleton.GetUniqueName(bone);
+
+            m_WeightPainterPanel.SetBoneSelectionByName(boneName);
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            base.Initialize(layout);
+
+            m_WeightPainterPanel = WeightPainterPanel.GenerateFromUXML();
+            m_WeightPainterPanel.SetHiddenFromLayout(true);
+            layout.rightOverlay.Add(m_WeightPainterPanel);
+
+            m_WeightPainterPanel.sliderStarted += () =>
+                {
+                    EditStart(skinningCache.vertexSelection, false);
+                };
+            m_WeightPainterPanel.sliderChanged += (value) =>
+                {
+                    EditWeights(value, true);
+                    meshTool.UpdateWeights();
+                };
+            m_WeightPainterPanel.sliderEnded += () =>
+                {
+                    EditEnd();
+                };
+            m_WeightPainterPanel.bonePopupChanged += (i) =>
+                {
+                    var skeleton = skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+
+                    if (skeleton != null)
+                    {
+                        BoneCache bone = null;
+
+                        if (i != -1)
+                            bone = skeleton.GetBone(i).ToCharacterIfNeeded();
+
+                        if(bone != skinningCache.skeletonSelection.activeElement)
+                        {
+                            using (skinningCache.UndoScope(TextContent.boneSelection))
+                            {
+                                skinningCache.skeletonSelection.activeElement = bone;
+                                InvokeBoneSelectionChanged();
+                            }
+                        }
+                    }
+                };
+            m_WeightPainterPanel.weightsChanged += () => meshTool.UpdateWeights();
+        }
+
+        internal void SetWeightPainterPanelTitle(string title)
+        {
+            m_WeightPainterPanel.title = title;
+        }
+
+        private void AssociateSelectedBoneToCharacterPart()
+        {
+            var mesh = meshTool.mesh;
+
+            if (skinningCache.hasCharacter 
+                && skinningCache.mode == SkinningMode.Character
+                && m_WeightPainterPanel.boneIndex != -1 
+                && mesh != null)
+            {
+                var skeleton = skinningCache.character.skeleton;
+
+                Debug.Assert(skeleton != null);
+
+                var bone = skeleton.GetBone(m_WeightPainterPanel.boneIndex);
+
+                if (!mesh.ContainsBone(bone))
+                {
+                    using (skinningCache.UndoScope(TextContent.addBoneInfluence))
+                    {
+                        var characterPart = mesh.sprite.GetCharacterPart();
+                        var characterBones = characterPart.bones.ToList();
+                        characterBones.Add(bone);
+                        characterPart.bones = characterBones.ToArray();
+                        skinningCache.events.characterPartChanged.Invoke(characterPart);
+                        m_WeightPainterPanel.UpdateWeightInspector(meshTool.mesh, GetMeshBoneNames(), skinningCache.vertexSelection, skinningCache);
+                    }
+                }
+            }
+        }
+        
+        private void EditStart(ISelection<int> selection, bool relative)
+        {
+            AssociateSelectedBoneToCharacterPart();
+
+            SetupWeightEditor(selection);
+
+            if (m_WeightEditor.spriteMeshData != null)
+                m_WeightEditor.OnEditStart(relative);
+        }
+
+        private void EditWeights(float hardness, bool emptySelectionEditsAll)
+        {
+            m_WeightEditor.emptySelectionEditsAll = emptySelectionEditsAll;
+
+            if (m_WeightEditor.spriteMeshData != null)
+                m_WeightEditor.DoEdit(hardness);
+        }
+
+        private void EditEnd()
+        {
+            if (m_WeightEditor.spriteMeshData != null)
+            {
+                m_WeightEditor.OnEditEnd();
+                meshTool.UpdateWeights();
+            }
+        }
+
+        private void InvokeBoneSelectionChanged()
+        {
+            skinningCache.events.boneSelectionChanged.RemoveListener(OnBoneSelectionChanged);
+            skinningCache.events.boneSelectionChanged.Invoke();
+            skinningCache.events.boneSelectionChanged.AddListener(OnBoneSelectionChanged);
+        }
+
+        private int ConvertBoneIndex(int index)
+        {
+            if (index != -1 && meshTool.mesh != null)
+            {
+                var skeleton = skinningCache.GetEffectiveSkeleton(meshTool.mesh.sprite);
+
+                if (skeleton != null)
+                {
+                    var bone = skeleton.GetBone(index).ToCharacterIfNeeded();
+                    index = Array.IndexOf(meshTool.mesh.bones, bone);
+                }
+            }
+
+            return index;
+        }
+
+        private void SetupWeightEditor(ISelection<int> selection)
+        {
+            m_WeightEditor.spriteMeshData = meshTool.mesh;
+            m_WeightEditor.mode = m_WeightPainterPanel.mode;
+            m_WeightEditor.boneIndex = ConvertBoneIndex(m_WeightPainterPanel.boneIndex);
+            m_WeightEditor.autoNormalize = m_WeightPainterPanel.normalize;
+            m_WeightEditor.selection = selection;
+            m_WeightEditor.emptySelectionEditsAll = true;
+        }
+
+        private void UpdateBrushSelection(Brush brush)
+        {
+            m_BrushSelection.Clear();
+            m_CircleVertexSelector.spriteMeshData = meshTool.mesh;
+            m_CircleVertexSelector.position = brush.position;
+            m_CircleVertexSelector.radius = brush.size;
+            m_CircleVertexSelector.selection = m_BrushSelection;
+            m_CircleVertexSelector.Select();
+        }
+
+        private void DrawBrush(Brush brush)
+        {
+            var oldColor =  Handles.color;
+            Handles.color = Color.white;
+
+            if (EditorGUI.actionKey)
+                Handles.color = Color.red;
+            if (brush.isHot)
+                Handles.color = Color.yellow;
+
+            Handles.DrawWireDisc(brush.position, Vector3.forward, brush.size);
+            Handles.color = oldColor;
+        }
+
+        protected override void OnGUI()
+        {
+            m_MeshPreviewBehaviour.showWeightMap = true;
+            m_MeshPreviewBehaviour.overlaySelected = true;
+            skeletonTool.skeletonStyle = SkeletonStyles.WeightMap;
+
+            skeletonMode = SkeletonMode.EditPose;
+            meshMode = SpriteMeshViewMode.EditGeometry;
+            disableMeshEditor = true;
+
+            var isBoneHovered = skeletonTool.hoveredBone != null && !m_Brush.isHot;
+            var useBrush = paintMode == WeightPainterMode.Brush;
+
+            meshTool.selectionOverride = null;
+
+            if (useBrush)
+                meshTool.selectionOverride = m_BrushSelection;
+
+            DoSkeletonGUI();
+            DoMeshGUI();
+
+            if (useBrush && !isBoneHovered)
+            {
+                var handlesMatrix = Handles.matrix;
+                var selectedSprite = skinningCache.selectedSprite;
+                var matrix = Matrix4x4.identity;
+
+                if (selectedSprite != null)
+                    matrix = selectedSprite.GetLocalToWorldMatrixFromMode();
+
+                Handles.matrix *= matrix;
+
+                skinningCache.brushSize = m_Brush.size = m_WeightPainterPanel.size;
+                skinningCache.brushHardness = m_Brush.hardness = m_WeightPainterPanel.hardness;
+                skinningCache.brushStep = m_Brush.step = m_WeightPainterPanel.step;
+
+                if (m_Brush.isHot || !skinningCache.IsOnVisualElement())
+                {
+                    meshTool.BeginPositionOverride();
+                    m_Brush.OnGUI();
+                    meshTool.EndPositionOverride();
+                }
+
+                Handles.matrix = handlesMatrix;
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightPainterTool.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightPainterToolWrapper.cs

@@ -0,0 +1,60 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class WeightPainterToolWrapper : BaseTool
+    {
+        [SerializeField]
+        private WeightPainterMode m_PaintMode;
+
+        [SerializeField]
+        private WeightPainterTool m_WeightPainterTool;
+
+        private string m_Title;
+
+        public override IMeshPreviewBehaviour previewBehaviour
+        {
+            get { return m_WeightPainterTool.previewBehaviour; }
+        }
+
+        public WeightPainterTool weightPainterTool
+        {
+            get { return m_WeightPainterTool; }
+            set { m_WeightPainterTool = value; }
+        }
+
+        public WeightPainterMode paintMode
+        {
+            get { return m_PaintMode; }
+            set { m_PaintMode = value; }
+        }
+
+        public string title
+        {
+            set { m_Title = value; }
+        }
+
+        public override int defaultControlID
+        {
+            get { return weightPainterTool.defaultControlID; }
+        }
+
+        protected override void OnActivate()
+        {
+            weightPainterTool.Activate();
+            weightPainterTool.panelTitle = m_Title;
+        }
+
+        protected override void OnDeactivate()
+        {
+            weightPainterTool.Deactivate();
+        }
+
+        protected override void OnGUI()
+        {
+            weightPainterTool.paintMode = paintMode;
+
+            weightPainterTool.DoGUI();
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightPainterToolWrapper.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryAssetInspector.cs

@@ -0,0 +1,197 @@
+using UnityEditor.U2D.Animation;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Experimental.U2D.Animation;
+
+namespace UnityEditor.Experimental.U2D.Animation
+{
+    [CustomEditor(typeof(SpriteLibraryAsset))]
+    internal class SpriteLibraryAssetInspector : Editor
+    {
+        static class Style
+        {
+            public static GUIContent duplicateWarningText = EditorGUIUtility.TrTextContent("Duplicate name found or name hash clashes. Please use a different name");
+            public static GUIContent duplicateWarning = EditorGUIUtility.TrIconContent("console.warnicon.sml", duplicateWarningText.text);
+            public static GUIContent nameLabel = new GUIContent(TextContent.label);
+            public static string categoryListLabel = L10n.Tr("Category List");
+            public static int lineSpacing = 3;
+        }
+
+        private SerializedProperty m_Labels;
+        private ReorderableList m_LabelReorderableList;
+
+        private bool m_UpdateHash = false;
+
+        private readonly float kElementHeight = EditorGUIUtility.singleLineHeight * 3;
+
+        public void OnEnable()
+        {
+            m_Labels = serializedObject.FindProperty("m_Labels");
+
+            m_LabelReorderableList = new ReorderableList(serializedObject, m_Labels, true, false, true, true);
+            SetupOrderList();
+        }
+
+        public void OnDisable()
+        {
+            var sla = target as SpriteLibraryAsset;
+            if (sla != null)
+                sla.UpdateHashes();
+        }
+
+        float GetElementHeight(int index)
+        {
+            var property = m_Labels.GetArrayElementAtIndex(index);
+            var spriteListProp = property.FindPropertyRelative("m_CategoryList");
+            if (spriteListProp.isExpanded)
+                return (spriteListProp.arraySize + 1) * (EditorGUIUtility.singleLineHeight + Style.lineSpacing) + kElementHeight;
+
+            return kElementHeight;
+        }
+
+        void DrawElement(Rect rect, int index, bool selected, bool focused)
+        {
+            var property = m_Labels.GetArrayElementAtIndex(index);
+
+            var catRect = new Rect(rect.x, rect.y, rect.width - kElementHeight, EditorGUIUtility.singleLineHeight);
+            var vaRect = new Rect(rect.x, rect.y + EditorGUIUtility.singleLineHeight, rect.width - kElementHeight, EditorGUIUtility.singleLineHeight);
+
+            var categoryProp = property.FindPropertyRelative("m_Name");
+
+            var spriteListProp = property.FindPropertyRelative("m_CategoryList");
+
+            EditorGUI.BeginChangeCheck();
+            var newCatName = EditorGUI.DelayedTextField(catRect, categoryProp.stringValue);
+            if (EditorGUI.EndChangeCheck())
+            {
+                newCatName = newCatName.Trim();
+                m_UpdateHash = true;
+                if (categoryProp.stringValue != newCatName)
+                {
+                    // Check if this nameLabel is already taken
+                    if (!IsNameInUsed(newCatName, m_Labels, "m_Name", 0))
+                        categoryProp.stringValue = newCatName;
+                    else
+                        Debug.LogWarning(Style.duplicateWarningText.text);
+                }
+            }
+
+            spriteListProp.isExpanded = EditorGUI.Foldout(vaRect, spriteListProp.isExpanded, Style.categoryListLabel, true);
+            if (spriteListProp.isExpanded)
+            {
+                EditorGUI.indentLevel++;
+                var indentedRect = EditorGUI.IndentedRect(vaRect);
+                var labelWidth = EditorGUIUtility.labelWidth;
+                EditorGUIUtility.labelWidth = 40 + indentedRect.x - vaRect.x;
+                indentedRect.y += EditorGUIUtility.singleLineHeight + Style.lineSpacing;
+                var sizeRect = indentedRect;
+                int size = EditorGUI.IntField(sizeRect, TextContent.size, spriteListProp.arraySize);
+                if (size != spriteListProp.arraySize && size >= 0)
+                    spriteListProp.arraySize = size;
+                indentedRect.y += EditorGUIUtility.singleLineHeight + Style.lineSpacing;
+                DrawSpriteListProperty(indentedRect, spriteListProp);
+                EditorGUIUtility.labelWidth = labelWidth;
+                EditorGUI.indentLevel--;
+            }
+        }
+
+        void DrawSpriteListProperty(Rect rect, SerializedProperty spriteListProp)
+        {
+            for (int i = 0; i < spriteListProp.arraySize; ++i)
+            {
+                var element = spriteListProp.GetArrayElementAtIndex(i);
+                EditorGUI.BeginChangeCheck();
+                var oldName = element.FindPropertyRelative("m_Name").stringValue;
+                var nameRect = new Rect(rect.x, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight);
+                bool nameDuplicate = IsNameInUsed(oldName, spriteListProp, "m_Name", 1);
+                if (nameDuplicate)
+                {
+                    nameRect.width -= 20;
+                }
+                var newName = EditorGUI.DelayedTextField(
+                    nameRect,
+                    Style.nameLabel,
+                    oldName);
+                if (nameDuplicate)
+                {
+                    nameRect.x += nameRect.width;
+                    nameRect.width = 20;
+                    GUI.Label(nameRect, Style.duplicateWarning);
+                }
+                if (EditorGUI.EndChangeCheck())
+                {
+                    newName = newName.Trim();
+                    element.FindPropertyRelative("m_Name").stringValue = newName;
+                }
+
+                EditorGUI.PropertyField(new Rect(rect.x + rect.width / 2 + 5, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("m_Sprite"));
+                rect.y += EditorGUIUtility.singleLineHeight + Style.lineSpacing;
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+            if (EditorGUI.EndChangeCheck())
+                SetupOrderList();
+
+            m_UpdateHash = false;
+            m_LabelReorderableList.DoLayoutList();
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (m_UpdateHash)
+                (target as SpriteLibraryAsset).UpdateHashes();
+        }
+
+        bool IsNameInUsed(string name, SerializedProperty property, string propertyField, int threshold)
+        {
+            int count = 0;
+            var nameHash = SpriteLibraryAsset.GetStringHash(name);
+            for (int i = 0; i < property.arraySize; ++i)
+            {
+                var sp = property.GetArrayElementAtIndex(i);
+                var otherName = sp.FindPropertyRelative(propertyField).stringValue;
+                var otherNameHash = SpriteLibraryAsset.GetStringHash(otherName);
+                if (otherName == name || nameHash == otherNameHash)
+                {
+                    count++;
+                    if (count > threshold)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        void OnAddCallback(ReorderableList list)
+        {
+            var oldSize = m_Labels.arraySize;
+            m_Labels.arraySize += 1;
+            const string kNewCatName = "New Category";
+            string newCatName = kNewCatName;
+            int catNameIncrement = 1;
+            while (true)
+            {
+                if (IsNameInUsed(newCatName, m_Labels, "m_Name", 0))
+                    newCatName = string.Format("{0} {1}", kNewCatName, catNameIncrement++);
+                else
+                    break;
+            }
+
+            var sp = m_Labels.GetArrayElementAtIndex(oldSize);
+            sp.FindPropertyRelative("m_Name").stringValue = newCatName;
+            sp.FindPropertyRelative("m_Hash").intValue = SpriteLibraryAsset.GetStringHash(newCatName);
+        }
+
+        private void SetupOrderList()
+        {
+            m_LabelReorderableList.drawElementCallback = DrawElement;
+            m_LabelReorderableList.elementHeight = kElementHeight;
+            m_LabelReorderableList.elementHeightCallback = GetElementHeight;
+            m_LabelReorderableList.onAddCallback = OnAddCallback;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryAssetInspector.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryDataProvider.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.U2D.Animation;
+using UnityEngine.Serialization;
+
+namespace UnityEditor.U2D.Animation
+{
+    /// <summary>
+    /// Structure that defines a Sprite Library Category Label
+    /// </summary>
+    [Serializable]
+    public struct SpriteCategoryLabel
+    {
+        [SerializeField]
+        string m_Name;
+        [SerializeField]
+        string m_SpriteId;
+
+        /// <summary>
+        /// Get and set the name for the Sprite label
+        /// </summary>
+        public string name
+        {
+            get { return m_Name; }
+            set { m_Name = value; }
+        }
+
+        /// <summary>
+        /// Get and set the Sprite Id.
+        /// </summary>
+        public string spriteId
+        {
+            get { return m_SpriteId; }
+            set { m_SpriteId = value; }
+        }
+    }
+
+    /// <summary>
+    /// Structure that defines a Sprite Library Category.
+    /// </summary>
+    [Serializable]
+    public struct SpriteCategory
+    {
+        [SerializeField]
+        [FormerlySerializedAs("name")]
+        string m_Name;
+        [SerializeField]
+        List<SpriteCategoryLabel> m_Labels;
+
+        /// <summary>
+        /// Get and set the name for the Sprite Category
+        /// </summary>
+        public string name
+        {
+            get { return m_Name; }
+            set { m_Name = value; }
+        }
+
+        /// <summary>
+        /// Get and set the Sprites registered to this category.
+        /// </summary>
+        public List<SpriteCategoryLabel> labels
+        {
+            get { return m_Labels; }
+            set { m_Labels = value; }
+        }
+    }
+
+    /// <summary>
+    /// A structure to hold a collection of SpriteCategory
+    /// </summary>
+    [Serializable]
+    public struct SpriteCategoryList
+    {
+        [SerializeField]
+        [FormerlySerializedAs("categories")]
+        List<SpriteCategory> m_Categories;
+
+        /// <summary>
+        /// Get or set the a list of SpriteCategory
+        /// </summary>
+        public List<SpriteCategory> categories
+        {
+            get { return m_Categories; }
+            set { m_Categories = value; }
+        }
+    }
+
+    internal class SpriteCategoryListCacheObject : SkinningObject
+    {
+        [SerializeField]
+        public List<SpriteCategory> categories = new List<SpriteCategory>();
+
+        public void CopyFrom(SpriteCategoryList categoryList)
+        {
+            categories.Clear();
+            foreach (var cat in categoryList.categories)
+            {
+                var spriteLibCategory = new SpriteCategory()
+                {
+                    name = cat.name,
+                    labels = new List<SpriteCategoryLabel>(cat.labels)
+                };
+                categories.Add(spriteLibCategory);
+            }
+        }
+
+        public SpriteCategoryList ToSpriteLibrary()
+        {
+            var spriteLibrary = new SpriteCategoryList();
+            spriteLibrary.categories = new List<SpriteCategory>();
+            foreach (var cat in categories)
+            {
+                var spriteLibCategory = new SpriteCategory()
+                {
+                    name = cat.name,
+                    labels = new List<SpriteCategoryLabel>(cat.labels)
+                };
+                spriteLibrary.categories.Add(spriteLibCategory);
+            }
+            return spriteLibrary;
+        }
+
+        public void RemoveSpriteFromCategory(string sprite)
+        {
+            for (int i = 0; i < categories.Count; ++i)
+            {
+                var index = categories[i].labels.FindIndex(x => x.spriteId == sprite);
+                if (index != -1)
+                    categories[i].labels.RemoveAt(index);
+            }
+        }
+
+        public void AddSpriteToCategory(string category, SpriteCategoryLabel label)
+        {
+            if (string.IsNullOrEmpty(category) || string.IsNullOrEmpty(label.name))
+            {
+                // Remove sprite from name
+                RemoveSpriteFromCategory(label.spriteId);
+            }
+            else
+            {
+                //find cateogry
+                var categoryIndex = categories.FindIndex(x => x.name == category);
+                if (categoryIndex == -1)
+                {
+                    // check if the hash might clash
+                    var hash = SpriteLibraryAsset.GetStringHash(category);
+                    if (categories.FindIndex(x => x.name != category && SpriteLibraryAsset.GetStringHash(x.name) == hash) != -1)
+                    {
+                        Debug.LogError("Unable to add Sprite to new Category due to name hash clash");
+                        return;
+                    }
+                }
+                var insertCategory = categoryIndex != -1 ? categories[categoryIndex] : new SpriteCategory() { name = category, labels = new List<SpriteCategoryLabel>() };
+                if (insertCategory.labels.FindIndex(x => x.spriteId == label.spriteId) == -1)
+                    insertCategory.labels.Add(label);
+
+                // now remove everything that has this sprite
+                foreach (var cat in categories)
+                {
+                    if (cat.name != category)
+                        cat.labels.RemoveAll(x => x.spriteId == label.spriteId);
+                }
+                if (categoryIndex == -1)
+                    categories.Add(insertCategory);
+                else
+                    categories[categoryIndex] = insertCategory;
+            }
+        }
+
+        public void ChangeSpriteLabelName(string labelname, string sprite)
+        {
+            // find name which contain sprite
+            var categoryIndex = -1;
+            var spriteIndex = -1;
+            for (int i = 0; i < categories.Count; ++i)
+            {
+                spriteIndex = categories[i].labels.FindIndex(x => x.spriteId == sprite);
+                if (spriteIndex != -1)
+                {
+                    categoryIndex = i;
+                    break;
+                }
+            }
+
+            if (categoryIndex != -1 && spriteIndex != -1)
+            {
+                var cat = categories[categoryIndex];
+                if (string.IsNullOrEmpty(labelname))
+                {
+                    cat.labels.RemoveAt(spriteIndex);
+                }
+                else
+                {
+                    var label = cat.labels[spriteIndex];
+                    label.name = labelname;
+                    cat.labels[spriteIndex] = label;
+                }
+            }
+        }
+    }
+
+    /// <summary>An interface that allows Sprite Editor Modules to edit Sprite Library data for user custom importer.</summary>
+    /// <remarks>Implement this interface for [[ScriptedImporter]] to leverage on Sprite Editor Modules to edit Sprite Library data.</remarks>
+    public interface ISpriteLibDataProvider
+    {
+        /// <summary>
+        /// Returns the SpriteCategoryList structure that represents the Sprite Library data.
+        /// </summary>
+        /// <returns>SpriteCategoryList data</returns>
+        SpriteCategoryList GetSpriteCategoryList();
+
+
+        /// <summary>
+        /// Sets the SpriteCategoryList structure that represents the Sprite Library data to the data provider
+        /// </summary>
+        /// <param name="spriteCategoryList">Data to set</param>
+        void SetSpriteCategoryList(SpriteCategoryList spriteCategoryList);
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryDataProvider.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryInspector.cs

@@ -0,0 +1,38 @@
+using UnityEngine.Experimental.U2D.Animation;
+
+namespace UnityEditor.Experimental.U2D.Animation
+{
+    [CustomEditor(typeof(SpriteLibrary))]
+    [CanEditMultipleObjects]
+    internal class SpriteLibraryInspector : Editor
+    {
+        private SerializedProperty m_SpriteLib;
+
+        public void OnEnable()
+        {
+            m_SpriteLib = serializedObject.FindProperty("m_SpriteLibraryAsset");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_SpriteLib);
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+
+                foreach (var t in targets)
+                {
+                    var srs = (t as SpriteLibrary).GetComponentsInChildren<SpriteResolver>();
+                    foreach (var sr in srs)
+                    {
+                        sr.ResolveSpriteToSpriteRenderer();
+                        sr.spriteLibChanged = true;
+                    }
+                }
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteLibraryInspector.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Logging/ILogItem.cs

@@ -0,0 +1,22 @@
+// -----------------------------------------------------------------------
+// <copyright file="ILogItem.cs" company="">
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+    .Logging
+{
+    using System;
+
+    /// <summary>
+    /// A basic log item interface.
+    /// </summary>
+    internal interface ILogItem
+    {
+        DateTime Time { get; }
+        LogLevel Level { get; }
+        string Message { get; }
+        string Info { get; }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Logging/ILogItem.cs.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Voronoi/BoundedVoronoi.cs

@@ -0,0 +1,183 @@
+// -----------------------------------------------------------------------
+// <copyright file="BoundedVoronoi.cs">
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+    .Voronoi
+{
+    using System.Collections.Generic;
+    using Animation.TriangleNet.Geometry;
+    using Animation.TriangleNet.Tools;
+    using Animation.TriangleNet.Topology.DCEL;
+
+    using HVertex = Animation.TriangleNet.Topology.DCEL.Vertex;
+    using TVertex = Animation.TriangleNet.Geometry.Vertex;
+
+    internal class BoundedVoronoi : VoronoiBase
+    {
+        int offset;
+
+        public BoundedVoronoi(Mesh mesh)
+            : this(mesh, new DefaultVoronoiFactory(), RobustPredicates.Default)
+        {
+        }
+
+        public BoundedVoronoi(Mesh mesh, IVoronoiFactory factory, IPredicates predicates)
+            : base(mesh, factory, predicates, true)
+        {
+            // We explicitly told the base constructor to call the Generate method, so
+            // at this point the basic Voronoi diagram is already created.
+            offset = base.vertices.Count;
+
+            // Each vertex of the hull will be part of a Voronoi cell.
+            base.vertices.Capacity = offset + mesh.hullsize;
+
+            // Create bounded Voronoi diagram.
+            PostProcess();
+
+            ResolveBoundaryEdges();
+        }
+
+        /// <summary>
+        /// Computes edge intersections with mesh boundary edges.
+        /// </summary>
+        private void PostProcess()
+        {
+            foreach (var edge in rays)
+            {
+                var twin = edge.twin;
+
+                var v1 = (TVertex)edge.face.generator;
+                var v2 = (TVertex)twin.face.generator;
+
+                double dir = predicates.CounterClockwise(v1, v2, edge.origin);
+
+                if (dir <= 0)
+                {
+                    HandleCase1(edge, v1, v2);
+                }
+                else
+                {
+                    HandleCase2(edge, v1, v2);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Case 1: edge origin lies inside the domain.
+        /// </summary>
+        private void HandleCase1(HalfEdge edge, TVertex v1, TVertex v2)
+        {
+            //int mark = GetBoundaryMark(v1);
+
+            // The infinite vertex.
+            var v = (Point)edge.twin.origin;
+
+            // The half-edge is the bisector of v1 and v2, so the projection onto the
+            // boundary segment is actually its midpoint.
+            v.x = (v1.x + v2.x) / 2.0;
+            v.y = (v1.y + v2.y) / 2.0;
+
+            // Close the cell connected to edge.
+            var gen = factory.CreateVertex(v1.x, v1.y);
+
+            var h1 = factory.CreateHalfEdge(edge.twin.origin, edge.face);
+            var h2 = factory.CreateHalfEdge(gen, edge.face);
+
+            edge.next = h1;
+            h1.next = h2;
+            h2.next = edge.face.edge;
+
+            gen.leaving = h2;
+
+            // Let the face edge point to the edge leaving at generator.
+            edge.face.edge = h2;
+
+            base.edges.Add(h1);
+            base.edges.Add(h2);
+
+            int count = base.edges.Count;
+
+            h1.id = count;
+            h2.id = count + 1;
+
+            gen.id = offset++;
+            base.vertices.Add(gen);
+        }
+
+        /// <summary>
+        /// Case 2: edge origin lies outside the domain.
+        /// </summary>
+        private void HandleCase2(HalfEdge edge, TVertex v1, TVertex v2)
+        {
+            // The vertices of the infinite edge.
+            var p1 = (Point)edge.origin;
+            var p2 = (Point)edge.twin.origin;
+
+            // The two edges leaving p1, pointing into the mesh.
+            var e1 = edge.twin.next;
+            var e2 = e1.twin.next;
+
+            // Find the two intersections with boundary edge.
+            IntersectionHelper.IntersectSegments(v1, v2, e1.origin, e1.twin.origin, ref p2);
+            IntersectionHelper.IntersectSegments(v1, v2, e2.origin, e2.twin.origin, ref p1);
+
+            // The infinite edge will now lie on the boundary. Update pointers:
+            e1.twin.next = edge.twin;
+            edge.twin.next = e2;
+            edge.twin.face = e2.face;
+
+            e1.origin = edge.twin.origin;
+
+            edge.twin.twin = null;
+            edge.twin = null;
+
+            // Close the cell.
+            var gen = factory.CreateVertex(v1.x, v1.y);
+            var he = factory.CreateHalfEdge(gen, edge.face);
+
+            edge.next = he;
+            he.next = edge.face.edge;
+
+            // Let the face edge point to the edge leaving at generator.
+            edge.face.edge = he;
+
+            base.edges.Add(he);
+
+            he.id = base.edges.Count;
+
+            gen.id = offset++;
+            base.vertices.Add(gen);
+        }
+
+        /*
+        private int GetBoundaryMark(Vertex v)
+        {
+            Otri tri = default(Otri);
+            Otri next = default(Otri);
+            Osub seg = default(Osub);
+
+            // Get triangle connected to generator.
+            v.tri.Copy(ref tri);
+            v.tri.Copy(ref next);
+
+            // Find boundary triangle.
+            while (next.triangle.id != -1)
+            {
+                next.Copy(ref tri);
+                next.OnextSelf();
+            }
+
+            // Find edge dual to current half-edge.
+            tri.LnextSelf();
+            tri.LnextSelf();
+
+            tri.SegPivot(ref seg);
+
+            return seg.seg.boundary;
+        }
+        //*/
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Voronoi/BoundedVoronoi.cs.meta

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