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/Assets/LayoutOverlay.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4817dc4ea8764f74298414d8ac0bb8d5
+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/Assets/SkinningModule.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4fccdb4aa9dd0db43becdec2eea211af
+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/BoneDrawingUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4e0025ed472de854692946726304a452
+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/Cache.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d59ac20961f9b95419fd53d6c9663903
+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/CharacterModeTool.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6735c3e859fb15b4191b28f225534760
+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/ColorExtensions.cs

@@ -0,0 +1,13 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class ColorExtensions
+    {
+        public static Color AlphaMultiplied(this Color c, float multiplier)
+        {
+            return new Color(c.r, c.g, c.b, c.a * multiplier);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 10889aecec5b6ee41a2a1626c4cfc07c
+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/CopyTool.cs

@@ -0,0 +1,661 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+using UnityEditor.U2D.Layout;
+using UnityEngine.U2D;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface ICopyToolStringStore
+    {
+        string stringStore
+        {
+            get;
+            set;
+        }
+    }
+
+    internal class SystemCopyBufferStringStore : ICopyToolStringStore
+    {
+        public string stringStore
+        {
+            get { return EditorGUIUtility.systemCopyBuffer; }
+            set { EditorGUIUtility.systemCopyBuffer = value; }
+        }
+    }
+
+    internal class CopyTool : MeshToolWrapper
+    {
+        public class NewBonesStore
+        {
+            public BoneCache[] newBones;
+            public Dictionary<string, string> newBoneNameDict;
+            public NewBonesStore()
+            {
+                newBones = null;
+                newBoneNameDict = new Dictionary<string, string>();
+            }
+
+            public void MapAllExistingBones()
+            {
+                foreach (var bone in newBones)
+                    newBoneNameDict.Add(bone.name, bone.name);
+            }
+        }
+        
+        private ICopyToolStringStore m_CopyToolStringStore;
+        private CopyToolView m_CopyToolView;
+
+        public float pixelsPerUnit
+        {
+            private get;
+            set;
+        }
+
+        public ICopyToolStringStore copyToolStringStore
+        {
+            set { m_CopyToolStringStore = value; }
+        }
+
+        internal override void OnCreate()
+        {
+            m_CopyToolView = new CopyToolView();
+            m_CopyToolView.onPasteActivated += OnPasteActivated;
+            m_CopyToolStringStore = new SystemCopyBufferStringStore();
+            disableMeshEditor = true;
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            m_CopyToolView.Initialize(layout);
+        }
+
+        protected override void OnActivate()
+        {
+            base.OnActivate();
+            m_CopyToolView.Show();
+        }
+
+        protected override void OnDeactivate()
+        {
+            base.OnDeactivate();
+            m_CopyToolView.Hide();
+        }
+
+        private void CopyMeshFromSpriteCache(SpriteCache sprite, SkinningCopySpriteData skinningSpriteData)
+        {
+            if (meshTool == null)
+                return;
+
+            meshTool.SetupSprite(sprite);
+            skinningSpriteData.vertices = meshTool.mesh.vertices;
+            skinningSpriteData.indices = meshTool.mesh.indices;
+            skinningSpriteData.edges = meshTool.mesh.edges;
+            skinningSpriteData.boneWeightNames = new List<string>();
+            foreach (var bone in meshTool.mesh.bones)
+            {
+                skinningSpriteData.boneWeightNames.Add(bone.name);
+            }
+        }
+
+        public void OnCopyActivated()
+        {
+            SkinningCopyData skinningCopyData;
+            var selectedSprite = skinningCache.selectedSprite;
+            if (selectedSprite == null)
+            {
+                skinningCopyData = CopyAll();
+            }
+            else
+            {
+                skinningCopyData = CopySingle(selectedSprite);
+            }
+
+            if (skinningCopyData != null)
+                m_CopyToolStringStore.stringStore = SkinningCopyUtility.SerializeSkinningCopyDataToString(skinningCopyData);
+            skinningCache.events.copy.Invoke();
+        }
+
+        public SkinningCopyData CopyAll()
+        {
+            var skinningCopyData = new SkinningCopyData();
+            skinningCopyData.pixelsPerUnit = pixelsPerUnit;
+
+            var sprites = skinningCache.GetSprites();
+            foreach (var sprite in sprites)
+            {
+                var skinningSpriteData = new SkinningCopySpriteData();
+                skinningSpriteData.spriteName = sprite.name;
+
+                var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+                if (skeleton != null && skeleton.BoneCount > 0)
+                {
+                    if (skinningCache.hasCharacter)
+                    {
+                        // Order doesn't matter for character bones
+                        skinningSpriteData.spriteBones = skeleton.bones.ToSpriteBone(Matrix4x4.identity).Select(x => new SpriteBoneCopyData()
+                        {
+                            spriteBone = x,
+                            order = -1
+                        }).ToList();
+                    }
+                        
+                    else
+                    {
+                        skinningSpriteData.spriteBones = new List<SpriteBoneCopyData>();
+                        var bones = skeleton.bones.FindRoots();
+                        foreach (var bone in bones)
+                            GetSpriteBoneDataRecursively(skinningSpriteData.spriteBones, bone, skeleton.bones.ToList());
+                    }
+                }
+                if (meshTool != null)
+                {
+                    CopyMeshFromSpriteCache(sprite, skinningSpriteData);
+                }
+                skinningCopyData.copyData.Add(skinningSpriteData);
+            }
+
+            if (meshTool != null)
+            {
+                meshTool.SetupSprite(null);
+            }
+
+            return skinningCopyData;
+        }
+
+        public SkinningCopyData CopySingle(SpriteCache sprite)
+        {
+            var skinningCopyData = new SkinningCopyData();
+            skinningCopyData.pixelsPerUnit = pixelsPerUnit;
+
+            // Mesh
+            var skinningSpriteData = new SkinningCopySpriteData();
+            skinningCopyData.copyData.Add(skinningSpriteData);
+
+            CopyMeshFromSpriteCache(sprite, skinningSpriteData);
+
+            // Bones
+            var rootBones = new List<BoneCache>();
+            BoneCache[] boneCache = null;
+            if (skinningCache.hasCharacter)
+            {
+                var characterPart = skinningCache.GetCharacterPart(sprite);
+                if (characterPart != null && characterPart.bones != null)
+                {
+                    boneCache = characterPart.bones;
+                    var bones = characterPart.bones.FindRoots();
+                    foreach (var bone in bones)
+                        rootBones.Add(bone);
+                }
+            }
+            else
+            {
+                var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+                if (skeleton != null && skeleton.BoneCount > 0)
+                {
+                    boneCache = skeleton.bones;
+                    var bones = boneCache.FindRoots();
+                    foreach (var bone in bones)
+                        rootBones.Add(bone);
+                }
+            }
+
+            if (rootBones.Count > 0)
+            {
+                skinningSpriteData.spriteBones = new List<SpriteBoneCopyData>();
+                foreach (var rootBone in rootBones)
+                {
+                    var rootBoneIndex = skinningSpriteData.spriteBones.Count;
+                    GetSpriteBoneDataRecursively(skinningSpriteData.spriteBones, rootBone, boneCache.ToList());
+                    if (skinningCache.hasCharacter)
+                    {
+                        // Offset the bones based on the currently selected Sprite in Character mode
+                        var characterPart = sprite.GetCharacterPart();
+                        if (characterPart != null)
+                        {
+                            var offset = characterPart.position;
+                            var rootSpriteBone = skinningSpriteData.spriteBones[rootBoneIndex];
+                            rootSpriteBone.spriteBone.position = rootSpriteBone.spriteBone.position - offset;
+                            skinningSpriteData.spriteBones[rootBoneIndex] = rootSpriteBone;
+                        }
+                    }
+                }
+            }
+
+            return skinningCopyData;
+        }
+
+        private void GetSpriteBoneDataRecursively(List<SpriteBoneCopyData> bones, BoneCache rootBone, List<BoneCache> boneCache)
+        {
+            AppendSpriteBoneDataRecursively(bones, rootBone, -1, boneCache);
+        }
+
+        private void AppendSpriteBoneDataRecursively(List<SpriteBoneCopyData> spriteBones, BoneCache bone, int parentIndex, List<BoneCache> boneCache)
+        {
+            int currentParentIndex = spriteBones.Count;
+
+            var boneCopyData = new SpriteBoneCopyData()
+            {
+                spriteBone = new SpriteBone()
+                {
+                    name = bone.name,
+                    parentId = parentIndex
+                },
+                order = boneCache.FindIndex(x => x == bone)
+            };
+            if (boneCopyData.order < 0)
+            {
+                boneCopyData.order = boneCache.Count;
+                boneCache.Add(bone);
+            }
+                
+            if (parentIndex == -1 && bone.parentBone != null)
+            {
+                boneCopyData.spriteBone.position = bone.position;
+                boneCopyData.spriteBone.rotation = bone.rotation;
+            }
+            else
+            {
+                boneCopyData.spriteBone.position = bone.localPosition;
+                boneCopyData.spriteBone.rotation = bone.localRotation;
+            }
+            boneCopyData.spriteBone.position = new Vector3(boneCopyData.spriteBone.position.x, boneCopyData.spriteBone.position.y, bone.depth);
+
+            boneCopyData.spriteBone.length = bone.localLength;
+            spriteBones.Add(boneCopyData);
+            foreach (var child in bone)
+            {
+                var childBone = child as BoneCache;
+                if (childBone != null)
+                    AppendSpriteBoneDataRecursively(spriteBones, childBone, currentParentIndex, boneCache);
+            }
+        }
+
+        public void OnPasteActivated(bool bone, bool mesh, bool flipX, bool flipY)
+        {
+            var copyBuffer = m_CopyToolStringStore.stringStore;
+            if (!SkinningCopyUtility.CanDeserializeStringToSkinningCopyData(copyBuffer))
+            {
+                Debug.LogError(TextContent.copyError1);
+                return;
+            }
+
+            var skinningCopyData = SkinningCopyUtility.DeserializeStringToSkinningCopyData(copyBuffer);
+            if (skinningCopyData == null || skinningCopyData.copyData.Count == 0)
+            {
+                Debug.LogError(TextContent.copyError2);
+                return;
+            }
+
+            var scale = 1f;
+            if (skinningCopyData.pixelsPerUnit > 0f)
+                scale = pixelsPerUnit / skinningCopyData.pixelsPerUnit;
+
+            var sprites = skinningCache.GetSprites();
+            var copyMultiple = skinningCopyData.copyData.Count > 1;
+            if (copyMultiple && skinningCopyData.copyData.Count != sprites.Length && mesh)
+            {
+                Debug.LogError(String.Format(TextContent.copyError3, sprites.Length, skinningCopyData.copyData.Count));
+                return;
+            }
+
+            using (skinningCache.UndoScope(TextContent.pasteData))
+            {
+                NewBonesStore newBonesStore = null;
+                if (bone && copyMultiple && skinningCache.hasCharacter)
+                {
+                    newBonesStore = new NewBonesStore();
+                    var skinningSpriteData = skinningCopyData.copyData[0];
+                    newBonesStore.newBones = skinningCache.CreateBoneCacheFromSpriteBones(skinningSpriteData.spriteBones.Select(y => y.spriteBone).ToArray(), scale);
+                    if (flipX || flipY)
+                    {
+                        var characterRect = new Rect(Vector2.zero, skinningCache.character.dimension);
+                        var newPositions = new Vector3[newBonesStore.newBones.Length];
+                        var newRotations = new Quaternion[newBonesStore.newBones.Length];
+                        for (var i = 0; i < newBonesStore.newBones.Length; ++i)
+                        {
+                            newPositions[i] = GetFlippedBonePosition(newBonesStore.newBones[i], Vector2.zero, characterRect, flipX, flipY);
+                            newRotations[i] = GetFlippedBoneRotation(newBonesStore.newBones[i], flipX, flipY);
+                        }
+                        for (var i = 0; i < newBonesStore.newBones.Length; ++i)
+                        {
+                            newBonesStore.newBones[i].position = newPositions[i];
+                            newBonesStore.newBones[i].rotation = newRotations[i];
+                        }
+                    }
+                    newBonesStore.MapAllExistingBones();
+                    var skeleton = skinningCache.character.skeleton;
+                    skeleton.SetBones(newBonesStore.newBones);
+                    skinningCache.events.skeletonTopologyChanged.Invoke(skeleton);
+                }
+
+                foreach (var skinningSpriteData in skinningCopyData.copyData)
+                {
+                    SpriteCache sprite = null;
+                    if (!String.IsNullOrEmpty(skinningSpriteData.spriteName))
+                    {
+                        sprite = sprites.FirstOrDefault(x => x.name == skinningSpriteData.spriteName);
+                    }
+                    if (sprite == null && (skinningCopyData.copyData.Count == 1 || String.IsNullOrEmpty(skinningSpriteData.spriteName)))
+                    {
+                        sprite = skinningCache.selectedSprite;
+                    }
+                    if (sprite == null)
+                        continue;
+
+                    if (bone && (!skinningCache.hasCharacter || !copyMultiple))
+                    {
+                        var spriteBones = new SpriteBone[skinningSpriteData.spriteBones.Count];
+                        for (int i = 0; i < skinningSpriteData.spriteBones.Count; ++i)
+                        {
+                            var order = skinningSpriteData.spriteBones[i].order;
+                            spriteBones[order] = skinningSpriteData.spriteBones[i].spriteBone;
+                            var parentId = spriteBones[order].parentId;
+                            if (parentId >= 0)
+                            {
+                                spriteBones[order].parentId = skinningSpriteData.spriteBones[parentId].order;
+                            }
+                        }
+                        newBonesStore = PasteSkeletonBones(sprite, spriteBones.ToList(), flipX, flipY, scale);
+                    }
+
+                    if (mesh && meshTool != null)
+                    {
+                        PasteMesh(sprite, skinningSpriteData, flipX, flipY, scale, newBonesStore);
+                    }
+                }
+
+                if (newBonesStore != null && newBonesStore.newBones != null)
+                {
+                    skinningCache.skeletonSelection.elements = newBonesStore.newBones;
+                    skinningCache.events.boneSelectionChanged.Invoke();
+                }
+            }
+            skinningCache.events.paste.Invoke(bone, mesh, flipX, flipY);
+        }
+
+        private Vector3 GetFlippedBonePosition(BoneCache bone, Vector2 startPosition, Rect spriteRect
+            , bool flipX, bool flipY)
+        {
+            Vector3 position = startPosition;
+            if (flipX)
+            {
+                position.x += spriteRect.width - bone.position.x;
+            }
+            else
+            {
+                position.x += bone.position.x;
+            }
+
+            if (flipY)
+            {
+                position.y += spriteRect.height - bone.position.y;
+            }
+            else
+            {
+                position.y += bone.position.y;
+            }
+
+            position.z = bone.position.z;
+            return position;
+        }
+
+        private Quaternion GetFlippedBoneRotation(BoneCache bone, bool flipX, bool flipY)
+        {
+            var euler = bone.rotation.eulerAngles;
+            if (flipX)
+            {
+                if (euler.z <= 180)
+                {
+                    euler.z = 180 - euler.z;
+                }
+                else
+                {
+                    euler.z = 540 - euler.z;
+                }
+            }
+            if (flipY)
+            {
+                euler.z = 360 - euler.z;
+            }
+            return Quaternion.Euler(euler);
+        }
+
+        void SetBonePositionAndRotation(BoneCache[] boneCache, TransformCache bone, Vector3[] position, Quaternion[] rotation)
+        {
+            var index = Array.FindIndex(boneCache, x => x == bone);
+            if (index >= 0)
+            {
+                bone.position = position[index];
+                bone.rotation = rotation[index];
+            }
+            foreach (var child in bone.children)
+            {
+                SetBonePositionAndRotation(boneCache, child, position, rotation);
+            }
+        }
+        
+        public NewBonesStore PasteSkeletonBones(SpriteCache sprite, List<SpriteBone> spriteBones, bool flipX, bool flipY, float scale = 1.0f)
+        {
+            NewBonesStore newBonesStore = new NewBonesStore();
+            newBonesStore.newBones = skinningCache.CreateBoneCacheFromSpriteBones(spriteBones.ToArray(), scale);
+            if (newBonesStore.newBones.Length == 0)
+                return null;
+
+            if (sprite == null || (skinningCache.mode == SkinningMode.SpriteSheet && skinningCache.hasCharacter))
+                return null;
+
+            var spriteRect = sprite.textureRect;
+            var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+
+            var rectPosition = spriteRect.position;
+            if (skinningCache.mode == SkinningMode.Character)
+            {
+                var characterPart = sprite.GetCharacterPart();
+                if (characterPart == null)
+                    return null;
+                rectPosition = characterPart.position;
+            }
+
+            var newPositions = new Vector3[newBonesStore.newBones.Length];
+            var newRotations = new Quaternion[newBonesStore.newBones.Length];
+            for (var i = 0; i < newBonesStore.newBones.Length; ++i)
+            {
+                newPositions[i] = GetFlippedBonePosition(newBonesStore.newBones[i], rectPosition, spriteRect, flipX, flipY);
+                newRotations[i] = GetFlippedBoneRotation(newBonesStore.newBones[i], flipX, flipY);
+            }
+            for (var i = 0; i < newBonesStore.newBones.Length; ++i)
+            {
+                if(newBonesStore.newBones[i].parent == null)
+                    SetBonePositionAndRotation(newBonesStore.newBones, newBonesStore.newBones[i], newPositions, newRotations);
+            }
+
+            if (skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                newBonesStore.MapAllExistingBones();
+                skeleton.SetBones(newBonesStore.newBones);
+            }
+            else
+            {
+                var existingBoneNames = skeleton.bones.Select(x => x.name).ToList();
+
+                skeleton.AddBones(newBonesStore.newBones);
+
+                var bones = skeleton.bones;
+
+                // Update names of all newly pasted bones
+                foreach (var bone in newBonesStore.newBones)
+                {
+                    if (existingBoneNames.Contains(bone.name))
+                    {
+                        var oldBoneName = bone.name;
+                        bone.name = SkeletonController.AutoBoneName(bone.parentBone, bones);
+                        existingBoneNames.Add(bone.name);
+                        newBonesStore.newBoneNameDict.Add(oldBoneName, bone.name);
+                    }
+                    else
+                    {
+                        newBonesStore.newBoneNameDict.Add(bone.name, bone.name);
+                    }
+                }
+
+                skeleton.SetDefaultPose();
+            }
+
+            skinningCache.events.skeletonTopologyChanged.Invoke(skeleton);
+            return newBonesStore;
+        }
+
+        public void PasteMesh(SpriteCache sprite, SkinningCopySpriteData skinningSpriteData, bool flipX, bool flipY, float scale, NewBonesStore newBonesStore)
+        {
+            if (sprite == null)
+                return;
+
+            meshTool.SetupSprite(sprite);
+            meshTool.mesh.vertices = skinningSpriteData.vertices;
+            if (!Mathf.Approximately(scale, 1f) || flipX || flipY)
+            {
+                var spriteRect = sprite.textureRect;
+                foreach (var vertex in meshTool.mesh.vertices)
+                {
+                    var position = vertex.position;
+                    if (!Mathf.Approximately(scale, 1f))
+                        position = position * scale;
+                    if (flipX)
+                        position.x = spriteRect.width - vertex.position.x;
+                    if (flipY)
+                        position.y = spriteRect.height - vertex.position.y;
+                    vertex.position = position;
+                }
+            }
+            meshTool.mesh.indices = skinningSpriteData.indices;
+            meshTool.mesh.edges = skinningSpriteData.edges;
+
+            int[] copyBoneToNewBones = new int[skinningSpriteData.boneWeightNames.Count];
+            BoneCache[] setBones = null;
+
+            if (newBonesStore != null && newBonesStore.newBones != null)
+            {
+                // Update bone weights with new bone indices
+                var setBonesList = new List<BoneCache>();
+                copyBoneToNewBones = new int[skinningSpriteData.boneWeightNames.Count];
+                int index = 0;
+                for (int i = 0; i < skinningSpriteData.boneWeightNames.Count; ++i)
+                {
+                    string oldBoneName = skinningSpriteData.boneWeightNames[i];
+                    string newBoneName;
+                    newBonesStore.newBoneNameDict.TryGetValue(oldBoneName, out newBoneName);
+                    var newBone = newBonesStore.newBones.FirstOrDefault(bone => bone.name == newBoneName);
+                    copyBoneToNewBones[i] = -1;
+                    if (newBone == null)
+                        continue;
+
+                    for (int j = 0; j < skinningSpriteData.spriteBones.Count; ++j)
+                    {
+                        if (skinningSpriteData.spriteBones[j].spriteBone.name == oldBoneName)
+                        {
+                            copyBoneToNewBones[i] = index++;
+                            setBonesList.Add(newBone);
+                            break;
+                        }
+                    }
+                }
+                setBones = setBonesList.ToArray();
+            }
+            else
+            {
+                // Attempt to link weights based on existing bone names
+                var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+                var characterBones = new List<BoneCache>();
+                for (int i = 0; i < skinningSpriteData.boneWeightNames.Count; ++i)
+                {
+                    copyBoneToNewBones[i] = -1;
+                    var boneName = skinningSpriteData.boneWeightNames[i];
+                    for (int j = 0; j < skeleton.bones.Length; ++j)
+                    {
+                        if (skeleton.bones[j].name == boneName)
+                        {
+                            copyBoneToNewBones[i] = characterBones.Count;
+                            characterBones.Add(skeleton.bones[j]);
+                            break;
+                        }
+                    }
+                }
+                setBones = characterBones.ToArray();
+            }
+
+            // Remap new bone indexes from copied bone indexes
+            foreach (var vertex in meshTool.mesh.vertices)
+            {
+                var editableBoneWeight = vertex.editableBoneWeight;
+
+                for (var i = 0; i < editableBoneWeight.Count; ++i)
+                {
+                    if (!editableBoneWeight[i].enabled)
+                        continue;
+
+                    if (copyBoneToNewBones.Length > editableBoneWeight[i].boneIndex)
+                    {
+                        var boneIndex = copyBoneToNewBones[editableBoneWeight[i].boneIndex];
+                        if (boneIndex != -1)
+                            editableBoneWeight[i].boneIndex = boneIndex;                        
+                    }
+                }
+            }
+
+            // Update associated bones for mesh
+            meshTool.mesh.SetCompatibleBoneSet(setBones);
+            meshTool.mesh.bones = setBones; // Fixes weights for bones that do not exist                
+
+            // Update associated bones for character
+            if (skinningCache.hasCharacter)
+            {
+                var characterPart = sprite.GetCharacterPart();
+                if (characterPart != null)
+                {
+                    characterPart.bones = setBones;
+                    skinningCache.events.characterPartChanged.Invoke(characterPart);
+                }
+            }
+
+            meshTool.UpdateMesh();
+        }
+    }
+
+    internal class CopyToolView
+    {
+        private PastePanel m_PastePanel;
+
+        public event Action<bool, bool, bool, bool> onPasteActivated = (bone, mesh, flipX, flipY) => {};
+
+        public void Show()
+        {
+            m_PastePanel.SetHiddenFromLayout(false);
+        }
+
+        public void Hide()
+        {
+            m_PastePanel.SetHiddenFromLayout(true);
+        }
+
+        public void Initialize(LayoutOverlay layoutOverlay)
+        {
+            m_PastePanel = PastePanel.GenerateFromUXML();
+            BindElements();
+            layoutOverlay.rightOverlay.Add(m_PastePanel);
+            m_PastePanel.SetHiddenFromLayout(true);
+        }
+
+        void BindElements()
+        {
+            m_PastePanel.onPasteActivated += OnPasteActivated;
+        }
+
+        void OnPasteActivated(bool bone, bool mesh, bool flipX, bool flipY)
+        {
+            onPasteActivated(bone, mesh, flipX, flipY);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 311e00422db8e4949bf926b0d039e05e
+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/DefaultPoseScope.cs

@@ -0,0 +1,55 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class DefaultPoseScope : IDisposable
+    {
+        private bool m_Disposed;
+        private SkeletonCache m_Skeleton;
+        private BonePose[] m_Pose;
+        private bool m_DoRestorePose = false;
+        private bool m_UseLocalPose;
+
+        public DefaultPoseScope(SkeletonCache skeleton, bool useLocalPose = true)
+        {
+            Debug.Assert(skeleton != null);
+
+            m_Skeleton = skeleton;
+            m_UseLocalPose = useLocalPose;
+
+            if (m_Skeleton.isPosePreview)
+            {
+                m_DoRestorePose = true;
+
+                if(useLocalPose)
+                    m_Pose = m_Skeleton.GetLocalPose();
+                else
+                    m_Pose = m_Skeleton.GetWorldPose();
+
+                m_Skeleton.RestoreDefaultPose();
+            }
+        }
+
+        ~DefaultPoseScope()
+        {
+            if (!m_Disposed)
+                Debug.LogError("Scope was not disposed! You should use the 'using' keyword or manually call Dispose.");
+        }
+
+        public void Dispose()
+        {
+            if (m_Disposed)
+                return;
+
+            m_Disposed = true;
+            if (m_Skeleton != null && m_DoRestorePose)
+            {
+                if(m_UseLocalPose)
+                    m_Skeleton.SetLocalPose(m_Pose);
+                else
+                    m_Skeleton.SetWorldPose(m_Pose);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bee8f4b5ba5b4ee46a3b10bad91b8c97
+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/DrawingUtility.cs

@@ -0,0 +1,261 @@
+using UnityEditor.U2D.Common;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class DrawingUtility
+    {
+        public static readonly Color kSpriteBorderColor = new Color(0.25f, 0.5f, 1f, 0.75f);
+
+        public static void DrawLine(Vector3 p1, Vector3 p2, Vector3 normal, float width)
+        {
+            DrawLine(p1, p2, normal, width, width);
+        }
+
+        public static void DrawLine(Vector3 p1, Vector3 p2, Vector3 normal, float widthP1, float widthP2)
+        {
+            DrawLine(p1, p2, normal, widthP1, widthP2, Handles.color);
+        }
+
+        public static void DrawLine(Vector3 p1, Vector3 p2, Vector3 normal, float widthP1, float widthP2, Color color)
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            Vector3 up = Vector3.Cross(normal, p2 - p1).normalized;
+
+            Shader.SetGlobalFloat("_HandleSize", 1);
+
+            InternalEditorBridge.ApplyWireMaterial();
+            GL.PushMatrix();
+            GL.MultMatrix(Handles.matrix);
+            GL.Begin(4);
+            GL.Color(color);
+            GL.Vertex(p1 + up * widthP1 * 0.5f);
+            GL.Vertex(p1 - up * widthP1 * 0.5f);
+            GL.Vertex(p2 - up * widthP2 * 0.5f);
+            GL.Vertex(p1 + up * widthP1 * 0.5f);
+            GL.Vertex(p2 - up * widthP2 * 0.5f);
+            GL.Vertex(p2 + up * widthP2 * 0.5f);
+            GL.End();
+            GL.PopMatrix();
+        }
+
+        public static void BeginLines(Color color)
+        {
+            InternalEditorBridge.ApplyWireMaterial();
+            GL.PushMatrix();
+            GL.MultMatrix(Handles.matrix);
+            GL.Begin(GL.LINES);
+            GL.Color(color);
+        }
+
+        public static void BeginSolidLines()
+        {
+            InternalEditorBridge.ApplyWireMaterial();
+            GL.PushMatrix();
+            GL.MultMatrix(Handles.matrix);
+            GL.Begin(GL.TRIANGLES);
+        }
+
+        public static void EndLines()
+        {
+            GL.End();
+            GL.PopMatrix();
+        }
+
+        public static void DrawLine(Vector3 p1, Vector3 p2)
+        {
+            GL.Vertex(p1);
+            GL.Vertex(p2);
+        }
+
+        public static void DrawSolidLine(float width, Vector3 p1, Vector3 p2)
+        {
+            DrawSolidLine(p1, p2, Vector3.forward, width, width);
+        }
+
+        public static void DrawSolidLine(Vector3 p1, Vector3 p2, Vector3 normal, float widthP1, float widthP2)
+        {
+            GL.Color(Handles.color);
+
+            Vector3 right = Vector3.Cross(normal, p2 - p1).normalized;
+
+            GL.Vertex(p1 + right * widthP1 * 0.5f);
+            GL.Vertex(p1 - right * widthP1 * 0.5f);
+            GL.Vertex(p2 - right * widthP2 * 0.5f);
+            GL.Vertex(p1 + right * widthP1 * 0.5f);
+            GL.Vertex(p2 - right * widthP2 * 0.5f);
+            GL.Vertex(p2 + right * widthP2 * 0.5f);
+        }
+
+        public static void DrawBox(Rect position)
+        {
+            Vector3[] points = new Vector3[5];
+            int i = 0;
+            points[i++] = new Vector3(position.xMin, position.yMin, 0f);
+            points[i++] = new Vector3(position.xMax, position.yMin, 0f);
+            points[i++] = new Vector3(position.xMax, position.yMax, 0f);
+            points[i++] = new Vector3(position.xMin, position.yMax, 0f);
+
+            DrawLine(points[0], points[1]);
+            DrawLine(points[1], points[2]);
+            DrawLine(points[2], points[3]);
+            DrawLine(points[3], points[0]);
+        }
+
+        public static void DrawMesh(Mesh mesh, Material material, Matrix4x4 matrix)
+        {
+            Debug.Assert(mesh != null);
+            Debug.Assert(material != null);
+
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            material.SetFloat("_AdjustLinearForGamma", PlayerSettings.colorSpace == ColorSpace.Linear ? 1.0f : 0.0f);
+            material.SetPass(0);
+            Graphics.DrawMeshNow(mesh, Handles.matrix * matrix);
+        }
+
+        public static void DrawGUIStyleCap(int controlID, Vector3 position, Quaternion rotation, float size, GUIStyle guiStyle)
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            if (Camera.current && Vector3.Dot(position - Camera.current.transform.position, Camera.current.transform.forward) < 0f)
+                return;
+
+            Handles.BeginGUI();
+            guiStyle.Draw(GetGUIStyleRect(guiStyle, position), GUIContent.none, controlID);
+            Handles.EndGUI();
+        }
+
+        private static Rect GetGUIStyleRect(GUIStyle style, Vector3 position)
+        {
+            Vector2 vector = HandleUtility.WorldToGUIPoint(position);
+
+            float fixedWidth = style.fixedWidth;
+            float fixedHeight = style.fixedHeight;
+
+            return new Rect(vector.x - fixedWidth / 2f, vector.y - fixedHeight / 2f, fixedWidth, fixedHeight);
+        }
+
+        public static void DrawRect(Rect rect, Vector3 position, Quaternion rotation, Color color, float rectAlpha, float outlineAlpha)
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            Vector3[] corners = new Vector3[4];
+            for (int i = 0; i < 4; i++)
+            {
+                Vector3 point = GetLocalRectPoint(rect, i);
+                corners[i] = rotation * point + position;
+            }
+
+            Vector3[] points = new Vector3[]
+            {
+                corners[0],
+                corners[1],
+                corners[2],
+                corners[3],
+                corners[0]
+            };
+
+            Color l_color = Handles.color;
+            Handles.color = color;
+
+            Vector2 offset = new Vector2(1f, 1f);
+
+            if (!Camera.current)
+            {
+                offset.y *= -1;
+            }
+
+            Handles.DrawSolidRectangleWithOutline(points, new Color(1f, 1f, 1f, rectAlpha), new Color(1f, 1f, 1f, outlineAlpha));
+
+            Handles.color = l_color;
+        }
+
+        private static Vector2 GetLocalRectPoint(Rect rect, int index)
+        {
+            switch (index)
+            {
+                case (0): return new Vector2(rect.xMin, rect.yMax);
+                case (1): return new Vector2(rect.xMax, rect.yMax);
+                case (2): return new Vector2(rect.xMax, rect.yMin);
+                case (3): return new Vector2(rect.xMin, rect.yMin);
+            }
+            return Vector3.zero;
+        }
+
+        private static void SetDiscSectionPoints(Vector3[] dest, int count, Vector3 normal, Vector3 from, float angle)
+        {
+            from.Normalize();
+            Quaternion rotation = Quaternion.AngleAxis(angle / (float)(count - 1), normal);
+            Vector3 vector = from;
+            for (int i = 0; i < count; i++)
+            {
+                dest[i] = vector;
+                vector = rotation * vector;
+            }
+        }
+
+        static Vector3[] s_array;
+        public static void DrawSolidArc(Vector3 center, Vector3 normal, Vector3 from, float angle, float radius, int numSamples = 60)
+        {
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            numSamples = Mathf.Clamp(numSamples, 3, 60);
+
+            if (s_array == null)
+                s_array = new Vector3[60];
+
+            Color color = Handles.color;
+            SetDiscSectionPoints(s_array, numSamples, normal, from, angle);
+            InternalEditorBridge.ApplyWireMaterial();
+            GL.PushMatrix();
+            GL.MultMatrix(Handles.matrix);
+            GL.Begin(GL.TRIANGLES);
+            for (int i = 1; i < numSamples; i++)
+            {
+                GL.Color(color);
+                GL.Vertex(center);
+                GL.Vertex(center + s_array[i - 1] * radius);
+                GL.Vertex(center + s_array[i] * radius);
+            }
+            GL.End();
+            GL.PopMatrix();
+        }
+
+        public static void DrawSolidArc(Vector3 center, Vector3 normal, Vector3 from, float angle, float radius, float outlineScale, int numSamples = 60)
+		{
+			if (Event.current.type != EventType.Repaint)
+				return;
+			
+            numSamples = Mathf.Clamp(numSamples, 3, 60);
+			
+			if(s_array == null)
+				s_array = new Vector3[60];
+				
+            Color color = Handles.color;
+            SetDiscSectionPoints(s_array, numSamples, normal, from, angle);
+			InternalEditorBridge.ApplyWireMaterial();
+			GL.PushMatrix();
+			GL.MultMatrix(Handles.matrix);
+			GL.Begin(4);
+			for (int i = 1; i < numSamples; i++)
+			{
+				GL.Color(color);
+				GL.Vertex(center + s_array[i - 1] * radius * outlineScale);
+				GL.Vertex(center + s_array[i - 1] * radius);
+				GL.Vertex(center + s_array[i] * radius);
+				GL.Vertex(center + s_array[i - 1] * radius * outlineScale);
+				GL.Vertex(center + s_array[i] * radius);
+				GL.Vertex(center + s_array[i] * radius * outlineScale);
+			}
+			GL.End();
+			GL.PopMatrix();
+		}
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9b3f77b5965944b8ba5c1beefa1eb533
+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/GenerateGeometryTool.cs

@@ -0,0 +1,215 @@
+using System;
+using UnityEditor.U2D.Layout;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class GenerateGeometryTool : MeshToolWrapper
+    {
+        private const float kWeightTolerance = 0.1f;
+        private SpriteMeshDataController m_SpriteMeshDataController = new SpriteMeshDataController();
+        private ITriangulator m_Triangulator;
+        private IOutlineGenerator m_OutlineGenerator;
+        private IWeightsGenerator m_WeightGenerator;
+        private GenerateGeometryPanel m_GenerateGeometryPanel;
+
+        internal override void OnCreate()
+        {
+            m_Triangulator = new Triangulator();
+            m_OutlineGenerator = new OutlineGenerator();
+            m_WeightGenerator = new BoundedBiharmonicWeightsGenerator();
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            base.Initialize(layout);
+
+            m_GenerateGeometryPanel = GenerateGeometryPanel.GenerateFromUXML();
+            m_GenerateGeometryPanel.skinningCache = skinningCache;
+
+            layout.rightOverlay.Add(m_GenerateGeometryPanel);
+
+            BindElements();
+            Hide();
+        }
+
+        private void BindElements()
+        {
+            Debug.Assert(m_GenerateGeometryPanel != null);
+
+            m_GenerateGeometryPanel.onAutoGenerateGeometry += (float d, byte a, float s) =>
+            {
+                var selectedSprite = skinningCache.selectedSprite;
+
+                if (selectedSprite != null)
+                {
+                    EditorUtility.DisplayProgressBar(TextContent.generatingGeometry, selectedSprite.name, 0f);
+
+                    using (skinningCache.UndoScope(TextContent.generateGeometry))
+                    {
+                        GenerateGeometry(selectedSprite, d / 100f, a, s);
+
+                        if (m_GenerateGeometryPanel.generateWeights)
+                        {
+                            EditorUtility.DisplayProgressBar(TextContent.generatingWeights, selectedSprite.name, 1f);
+                            GenerateWeights(selectedSprite);
+                        }
+
+                        skinningCache.vertexSelection.Clear();
+                        skinningCache.events.meshChanged.Invoke(selectedSprite.GetMesh());
+                    }
+
+                    EditorUtility.ClearProgressBar();
+                }
+            };
+
+            m_GenerateGeometryPanel.onAutoGenerateGeometryAll += (float d, byte a, float s) =>
+            {
+                var sprites = skinningCache.GetSprites();
+
+                using (skinningCache.UndoScope(TextContent.generateGeometry))
+                {
+                    for (var i = 0; i < sprites.Length; ++i)
+                    {
+                        var sprite = sprites[i];
+                        
+                        if (!sprite.IsVisible())
+                            continue;
+
+                        EditorUtility.DisplayProgressBar(TextContent.generateGeometry, sprite.name, i * 2f / (sprites.Length * 2f));
+
+                        GenerateGeometry(sprite, d / 100f, a, s);
+
+                        if (m_GenerateGeometryPanel.generateWeights)
+                        {
+                            EditorUtility.DisplayProgressBar(TextContent.generatingWeights, sprite.name, (i * 2f + 1) / (sprites.Length * 2f));
+                            GenerateWeights(sprite);
+                        }
+                    }
+
+                    foreach(var sprite in sprites)
+                        skinningCache.events.meshChanged.Invoke(sprite.GetMesh());
+
+                    EditorUtility.ClearProgressBar();
+                }
+            };
+        }
+
+        protected override void OnActivate()
+        {
+            base.OnActivate();
+            UpdateButton();
+            Show();
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSelectedSpriteChanged);
+        }
+
+        protected override void OnDeactivate()
+        {
+            base.OnDeactivate();
+            Hide();
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSelectedSpriteChanged);
+        }
+
+        private void Show()
+        {
+            m_GenerateGeometryPanel.SetHiddenFromLayout(false);
+        }
+
+        private void Hide()
+        {
+            m_GenerateGeometryPanel.SetHiddenFromLayout(true);
+        }
+
+        private void UpdateButton()
+        {
+            var selectedSprite = skinningCache.selectedSprite;
+
+            if (selectedSprite == null)
+                m_GenerateGeometryPanel.SetMode(GenerateGeometryPanel.GenerateMode.Multiple);
+            else
+                m_GenerateGeometryPanel.SetMode(GenerateGeometryPanel.GenerateMode.Single);
+        }
+
+        private void OnSelectedSpriteChanged(SpriteCache sprite)
+        {
+            UpdateButton();
+        }
+
+        private void GenerateGeometry(SpriteCache sprite, float outlineDetail, byte alphaTolerance, float subdivide)
+        {
+            Debug.Assert(sprite != null);
+
+            var mesh = sprite.GetMesh();
+
+            Debug.Assert(mesh != null);
+
+            m_SpriteMeshDataController.spriteMeshData = mesh;
+            m_SpriteMeshDataController.OutlineFromAlpha(m_OutlineGenerator, mesh.textureDataProvider, outlineDetail, alphaTolerance);
+            m_SpriteMeshDataController.Triangulate(m_Triangulator);
+
+            if (subdivide > 0f)
+            {
+                var largestAreaFactor = Mathf.Lerp(0.5f, 0.05f, Math.Min(subdivide, 100f) / 100f);
+                m_SpriteMeshDataController.Subdivide(m_Triangulator, largestAreaFactor);
+            }
+
+            foreach (var vertex in mesh.vertices)
+                vertex.position -= sprite.textureRect.position;
+        }
+
+        private void GenerateWeights(SpriteCache sprite)
+        {
+            Debug.Assert(sprite != null);
+
+            var mesh = sprite.GetMesh();
+
+            Debug.Assert(mesh != null);
+
+            using (new DefaultPoseScope(skinningCache.GetEffectiveSkeleton(sprite)))
+            {
+                if (NeedsAssociateBones(sprite.GetCharacterPart()))
+                {
+                    using (new AssociateBonesScope(sprite))
+                    {
+                        GenerateWeights(mesh);
+                    }
+                }
+                else
+                    GenerateWeights(mesh);
+            }
+        }
+
+        private bool NeedsAssociateBones(CharacterPartCache characterPart)
+        {
+            if (characterPart == null)
+                return false;
+
+            var skeleton = characterPart.skinningCache.character.skeleton;
+
+            return characterPart.BoneCount == 0 ||
+                    (characterPart.BoneCount == 1 && characterPart.GetBone(0) == skeleton.GetBone(0));
+        }
+
+        private void GenerateWeights(MeshCache mesh)
+        {
+            Debug.Assert(mesh != null);
+
+            m_SpriteMeshDataController.spriteMeshData = mesh;
+            m_SpriteMeshDataController.CalculateWeights(m_WeightGenerator, null, kWeightTolerance);
+            m_SpriteMeshDataController.SortTrianglesByDepth();
+        }
+
+        protected override void OnGUI()
+        {
+            m_MeshPreviewBehaviour.showWeightMap = m_GenerateGeometryPanel.generateWeights;
+            m_MeshPreviewBehaviour.overlaySelected = m_GenerateGeometryPanel.generateWeights;
+
+            skeletonTool.skeletonStyle = SkeletonStyles.Default;
+
+            if (m_GenerateGeometryPanel.generateWeights)
+                skeletonTool.skeletonStyle = SkeletonStyles.WeightMap;
+
+            DoSkeletonGUI();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 237f0a0a8eeab0d46873db954d4abded
+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/GenerateWeightsTool.cs

@@ -0,0 +1,147 @@
+using System;
+using UnityEditor.U2D.Layout;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class GenerateWeightsTool : MeshToolWrapper
+    {
+        private const float kWeightTolerance = 0.01f;
+        private SpriteMeshDataController m_SpriteMeshDataController = new SpriteMeshDataController();
+        private IWeightsGenerator m_WeightGenerator;
+        private GenerateWeightsPanel m_GenerateWeightsPanel;
+
+        internal override void OnCreate()
+        {
+            m_WeightGenerator = new BoundedBiharmonicWeightsGenerator();
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            base.Initialize(layout);
+
+            m_GenerateWeightsPanel = GenerateWeightsPanel.GenerateFromUXML();
+
+            layout.rightOverlay.Add(m_GenerateWeightsPanel);
+
+            BindElements();
+            m_GenerateWeightsPanel.SetHiddenFromLayout(true);
+        }
+
+        private void BindElements()
+        {
+            Debug.Assert(m_GenerateWeightsPanel != null);
+
+            m_GenerateWeightsPanel.onGenerateWeights += () =>
+            {
+                HandleWeights(GenerateWeights, TextContent.generateWeights);
+            };
+
+            m_GenerateWeightsPanel.onNormalizeWeights += () =>
+            {
+                HandleWeights(NormalizeWeights, TextContent.normalizeWeights);
+            };
+
+            m_GenerateWeightsPanel.onClearWeights += () =>
+            {
+                HandleWeights(ClearWeights, TextContent.clearWeights);
+            };
+        }
+
+        protected override void OnActivate()
+        {
+            base.OnActivate();
+            m_GenerateWeightsPanel.SetHiddenFromLayout(false);
+            skinningCache.events.skinningModeChanged.AddListener(OnModeChanged);
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSpriteSelectionChanged);
+            m_GenerateWeightsPanel.Update(skinningCache.mode == SkinningMode.Character);
+            OnSpriteSelectionChanged(skinningCache.selectedSprite);
+        }
+
+        protected override void OnDeactivate()
+        {
+            base.OnDeactivate();
+            skinningCache.events.skinningModeChanged.RemoveListener(OnModeChanged);
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSpriteSelectionChanged);
+            m_GenerateWeightsPanel.SetHiddenFromLayout(true);
+        }
+
+        void OnModeChanged(SkinningMode mode)
+        {
+            m_GenerateWeightsPanel.Update(mode == SkinningMode.Character);
+        }
+
+        void OnSpriteSelectionChanged(SpriteCache sprite)
+        {
+            m_GenerateWeightsPanel.generateButtonText = sprite != null ? TextContent.generate : TextContent.generateAll;
+        }
+
+        private void HandleWeights(Action<SpriteCache> action, string undoName)
+        {
+            using (skinningCache.UndoScope(undoName))
+            {
+                var selectedSprite = skinningCache.selectedSprite;
+                if (selectedSprite != null)
+                    HandleWeightsForSprite(selectedSprite, action);
+                else
+                {
+                    var sprites = skinningCache.GetSprites();
+
+                    foreach (var sprite in sprites)
+                    {
+                        if (sprite.IsVisible())
+                            HandleWeightsForSprite(sprite, action);
+                    }
+                }
+            }
+        }
+
+        private void HandleWeightsForSprite(SpriteCache sprite, Action<SpriteCache> action)
+        {
+            Debug.Assert(sprite != null);
+
+            using (new DefaultPoseScope(skinningCache.GetEffectiveSkeleton(sprite)))
+            {
+                action(sprite);
+            }
+
+            skinningCache.events.meshChanged.Invoke(sprite.GetMesh());
+        }
+
+        private void GenerateWeights(SpriteCache sprite)
+        {
+            using (m_GenerateWeightsPanel.associateBones ? new AssociateBonesScope(sprite) : null)
+            {
+                m_SpriteMeshDataController.spriteMeshData = sprite.GetMesh();
+                m_SpriteMeshDataController.CalculateWeights(m_WeightGenerator, skinningCache.vertexSelection, kWeightTolerance);
+                m_SpriteMeshDataController.SortTrianglesByDepth();
+            }
+        }
+
+        private void NormalizeWeights(SpriteCache sprite)
+        {
+            m_SpriteMeshDataController.spriteMeshData = sprite.GetMesh();
+            m_SpriteMeshDataController.NormalizeWeights(skinningCache.vertexSelection);
+            m_SpriteMeshDataController.SortTrianglesByDepth();
+        }
+
+        private void ClearWeights(SpriteCache sprite)
+        {
+            m_SpriteMeshDataController.spriteMeshData = sprite.GetMesh();
+            m_SpriteMeshDataController.ClearWeights(skinningCache.vertexSelection);
+        }
+
+        protected override void OnGUI()
+        {
+            m_MeshPreviewBehaviour.showWeightMap = true;
+            m_MeshPreviewBehaviour.overlaySelected = true;
+            skeletonMode = SkeletonMode.EditPose;
+            meshMode = SpriteMeshViewMode.EditGeometry;
+            disableMeshEditor = true;
+            skeletonTool.skeletonStyle = SkeletonStyles.WeightMap;
+
+            DoSkeletonGUI();
+            DoMeshGUI();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 497003cbd9cf35349bb7a01db4d94b26
+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/HorizontalToggleTools.cs

@@ -0,0 +1,166 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class HorizontalToggleTools
+    {
+        private static class Styles
+        {
+            public static GUIContent visibilityCollapseIcon = new GUIContent(IconUtility.LoadIconResource("Visibility_Tool", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.visibilityIconTooltip));
+            public static GUIContent visibilityIcon = new GUIContent(L10n.Tr(TextContent.visibilityIconText), IconUtility.LoadIconResource("Visibility_Tool", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.visibilityIconTooltip));
+            public static GUIContent characterCollapseIcon = new GUIContent(IconUtility.LoadIconResource("character_Mode", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.restorePose));
+            public static GUIContent characterIcon = new GUIContent(L10n.Tr(TextContent.characterIconText), IconUtility.LoadIconResource("character_Mode", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.restorePose));
+            public static GUIContent spriteSheetIcon = new GUIContent(L10n.Tr(TextContent.spriteSheetIconText), IconUtility.LoadIconResource("Sprite_Mode", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.spriteSheetIconTooltip));
+            public static GUIContent spriteSheetCollapseIcon = new GUIContent(IconUtility.LoadIconResource("Sprite_Mode", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.spriteSheetIconTooltip));
+            public static GUIContent copyIcon = new GUIContent(L10n.Tr(TextContent.copyText), IconUtility.LoadIconResource("Copy", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.copyTooltip));
+            public static GUIContent copyCollapseIcon = new GUIContent(IconUtility.LoadIconResource("Copy", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.copyTooltip));
+            public static GUIContent pasteIcon = new GUIContent(L10n.Tr(TextContent.pasteText), IconUtility.LoadIconResource("Paste", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.pasteTooltip));
+            public static GUIContent pasteCollapseIcon = new GUIContent(IconUtility.LoadIconResource("Paste", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr(TextContent.pasteTooltip));
+        }
+
+        private SkinningCache skinningCache { get; set; }
+
+        private CopyTool copyTool
+        {
+            get { return skinningCache.GetTool(Tools.CopyPaste) as CopyTool; }
+        }
+
+        private VisibilityTool visibilityTool
+        {
+            get { return skinningCache.GetTool(Tools.Visibility) as VisibilityTool; }
+        }
+
+        private SwitchModeTool switchmodeTool
+        {
+            get { return skinningCache.GetTool(Tools.SwitchMode) as SwitchModeTool; }
+        }
+
+        private GUIContent spriteSheetIcon
+        {
+            get { return collapseToolbar ? Styles.spriteSheetCollapseIcon : Styles.spriteSheetIcon; }
+        }
+
+        private GUIContent copyIcon
+        {
+            get { return collapseToolbar ? Styles.copyCollapseIcon : Styles.copyIcon; }
+        }
+        private GUIContent pasteIcon
+        {
+            get { return collapseToolbar ? Styles.pasteCollapseIcon : Styles.pasteIcon; }
+        }
+
+        internal Action<BaseTool> onActivateTool = (b) => {};
+        private BaseTool m_PreviousTool;
+
+        public bool collapseToolbar { get; set; }
+
+        internal HorizontalToggleTools(SkinningCache s)
+        {
+            skinningCache = s;
+        }
+
+        internal void DoGUI(Rect drawArea, BaseTool currentTool, bool isDisabled)
+        {
+            using (new EditorGUI.DisabledScope(isDisabled))
+            {
+                GUILayout.BeginArea(drawArea);
+                EditorGUILayout.BeginHorizontal();
+
+                DoPreviewToggle();
+                DoModeToggle();
+                DoCopyToggle(currentTool);
+                GUILayout.FlexibleSpace();
+                DoVisibilityToggle(currentTool);
+
+                EditorGUILayout.EndHorizontal();
+                GUILayout.EndArea();                
+            }
+        }
+
+        private void StorePreviousTool(BaseTool currentTool)
+        {
+            if(currentTool != copyTool && currentTool != visibilityTool)
+                m_PreviousTool = currentTool;
+        }
+
+        private void DoModeToggle()
+        {
+            if (skinningCache.hasCharacter)
+            {
+                EditorGUI.BeginChangeCheck();
+                var isActive = GUILayout.Toggle(switchmodeTool.isActive , spriteSheetIcon, EditorStyles.toolbarButton);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    using (skinningCache.UndoScope(TextContent.setMode))
+                    {
+                        if (isActive)
+                            switchmodeTool.Activate();
+                        else
+                            switchmodeTool.Deactivate();
+                    }
+                }
+            }
+        }
+
+        private void DoCopyToggle(BaseTool currentTool)
+        {
+            if (GUILayout.Button(copyIcon, EditorStyles.toolbarButton))
+            {
+                copyTool.OnCopyActivated();
+            }
+            EditorGUI.BeginChangeCheck();
+            GUILayout.Toggle(copyTool.isActive, pasteIcon, EditorStyles.toolbarButton);
+            if (EditorGUI.EndChangeCheck())
+                TogglePasteTool(currentTool);
+        }
+
+        internal void TogglePasteTool(BaseTool currentTool)
+        {
+            if (!copyTool.isActive)
+            {
+                onActivateTool(copyTool);
+                StorePreviousTool(currentTool);
+            }
+            else if (m_PreviousTool != null)
+            {
+                onActivateTool(m_PreviousTool);
+            }
+        }
+
+        void DoVisibilityToggle(BaseTool currentTool)
+        {
+            EditorGUI.BeginChangeCheck();
+            GUILayout.Toggle(visibilityTool.isActive, visbilityIcon, EditorStyles.toolbarButton);
+            if (EditorGUI.EndChangeCheck())
+                ToggleVisibilityTool(currentTool);
+        }
+
+        GUIContent visbilityIcon { get { return collapseToolbar ? Styles.visibilityCollapseIcon : Styles.visibilityIcon; } }
+
+        internal void ToggleVisibilityTool(BaseTool currentTool)
+        {
+            onActivateTool(visibilityTool);
+        }
+
+        private void DoPreviewToggle()
+        {
+            var skeleton = skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+
+            EditorGUI.BeginDisabledGroup(skeleton == null || skeleton.isPosePreview == false);
+            EditorGUI.BeginChangeCheck();
+            GUILayout.Button(characterIcon, EditorStyles.toolbarButton);
+            if (EditorGUI.EndChangeCheck())
+            {
+                using (skinningCache.UndoScope("Restore Pose"))
+                {
+                    skinningCache.RestoreBindPose();
+                    skinningCache.events.restoreBindPose.Invoke();
+                }
+            }
+            EditorGUI.EndDisabledGroup();
+        }
+
+        GUIContent characterIcon { get { return collapseToolbar ? Styles.characterCollapseIcon : Styles.characterIcon; } }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 28c640dd2a903f0498148ed21c25a97f
+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/IconUtility.cs

@@ -0,0 +1,30 @@
+using System.IO;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class IconUtility
+    {
+        static public readonly string k_LightIconResourcePath = "SkinningModule/Icons/Light";
+        static public readonly string k_DarkIconResourcePath = "SkinningModule/Icons/Dark";
+        static public readonly string k_SelectedResourceIconPath = "SkinningModule/Icons/Selected";
+
+        public static Texture2D LoadIconResource(string name, string personalPath, string proPath)
+        {
+            string iconPath = "";
+
+            if (EditorGUIUtility.isProSkin && !string.IsNullOrEmpty(proPath))
+                iconPath = Path.Combine(proPath, "d_" + name);
+            else
+                iconPath = Path.Combine(personalPath, name);
+            if (EditorGUIUtility.pixelsPerPoint > 1.0f)
+            {
+                var icon2x = ResourceLoader.Load<Texture2D>(iconPath + "@2x.png");
+                if (icon2x != null)
+                    return icon2x;
+            }
+
+            return ResourceLoader.Load<Texture2D>(iconPath+".png");
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e4f2af0145cfe44797338834d0b013a
+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/MeshPreviewTool.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9aa898c2e4f1cbc4ba5d122fc7b47317
+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/MeshTool.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9ee4e8d7932896548ab9dd0fa6efebc5
+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/ModuleToolGroup.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class ModuleToolGroup
+    {
+        class ToolGroupEntry
+        {
+            public BaseTool tool;
+            public Action activateCallback;
+        }
+
+        class ToolGroup
+        {
+            public int groupId;
+            public List<ToolGroupEntry> tools = new List<ToolGroupEntry>();
+            public int previousToolIndex;
+        }
+        List<ToolGroup> m_ToolGroups = new List<ToolGroup>();
+
+        public void AddToolToGroup(int groupId, BaseTool tool, Action toolActivatedCallback)
+        {
+            List<ToolGroupEntry> tools = null;
+            for (int i = 0; i < m_ToolGroups.Count; ++i)
+            {
+                if (m_ToolGroups[i].groupId == groupId)
+                {
+                    tools = m_ToolGroups[i].tools;
+                }
+
+                var toolIndex = m_ToolGroups[i].tools.FindIndex(x => x.tool == tool);
+                if (toolIndex != -1)
+                {
+                    Debug.LogError(string.Format("{0} already exist in group.", tool.name));
+                    return;
+                }
+            }
+
+            if (tools == null)
+            {
+                var toolGroup = new ToolGroup()
+                {
+                    groupId = groupId
+                };
+                tools = toolGroup.tools;
+                m_ToolGroups.Add(toolGroup);
+            }
+
+            tools.Add(new ToolGroupEntry()
+            {
+                tool = tool,
+                activateCallback = toolActivatedCallback
+            });
+        }
+
+        public void ActivateTool(BaseTool tool)
+        {
+            var toolGroupIndex = -1;
+            var groupTool = m_ToolGroups.FirstOrDefault(x =>
+            {
+                toolGroupIndex = x.tools.FindIndex(y => y.tool == tool);
+                return toolGroupIndex >= 0;
+            });
+
+            if (groupTool != null && toolGroupIndex >= 0)
+            {
+                var previousTool = groupTool.previousToolIndex >= 0 ? groupTool.tools[groupTool.previousToolIndex] : null;
+                if (tool.isActive) // we want to deactivate the tool and switch to original
+                {
+                    tool.Deactivate();
+                    if (previousTool != null && previousTool.tool != tool && previousTool.tool != null)
+                    {
+                        previousTool.tool.Activate();
+                        groupTool.previousToolIndex = toolGroupIndex;
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < groupTool.tools.Count; ++i)
+                    {
+                        var gt = groupTool.tools[i];
+                        if (gt.tool.isActive)
+                        {
+                            groupTool.previousToolIndex = i;
+                            gt.tool.Deactivate();
+                        }
+                    }
+                    tool.Activate();
+                    if (groupTool.tools[toolGroupIndex].activateCallback != null)
+                        groupTool.tools[toolGroupIndex].activateCallback();
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ebefc406fa7f065458cfccf8e07be2f9
+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/ModuleUtility.cs

@@ -0,0 +1,128 @@
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class ModuleUtility
+    {
+        public static Vector3 GUIToWorld(Vector3 guiPosition)
+        {
+            return GUIToWorld(guiPosition, Vector3.forward, Vector3.zero);
+        }
+
+        public static Vector3 GUIToWorld(Vector3 guiPosition, Vector3 planeNormal, Vector3 planePos)
+        {
+            Vector3 worldPos = Handles.inverseMatrix.MultiplyPoint(guiPosition);
+
+            if (Camera.current)
+            {
+                Ray ray = HandleUtility.GUIPointToWorldRay(guiPosition);
+
+                planeNormal = Handles.matrix.MultiplyVector(planeNormal);
+
+                planePos = Handles.matrix.MultiplyPoint(planePos);
+
+                Plane plane = new Plane(planeNormal, planePos);
+
+                float distance = 0f;
+
+                if (plane.Raycast(ray, out distance))
+                {
+                    worldPos = Handles.inverseMatrix.MultiplyPoint(ray.GetPoint(distance));
+                }
+            }
+
+            return worldPos;
+        }
+
+        public static GUIContent[] ToGUIContentArray(string[] names)
+        {
+            return Array.ConvertAll(names, n => new GUIContent(n));
+        }
+
+        public static Color CalculateNiceColor(int index, int numColors)
+        {
+            numColors = Mathf.Clamp(numColors, 1, int.MaxValue);
+
+            int loops = index / numColors;
+            index = index % 360;
+
+            int hueAngleStep = 360 / numColors;
+            float hueLoopOffset = hueAngleStep * 0.5f;
+            float hue = index * hueAngleStep + loops * hueLoopOffset;
+
+            return Color.HSVToRGB(Mathf.Repeat(hue, 360f) / 360f, 1f, 1f);
+        }
+
+        public static void UpdateLocalToWorldMatrices(List<SpriteBoneData> spriteBoneDataList, Matrix4x4 rootMatrix, ref Matrix4x4[] localToWorldMatrices)
+        {
+            if (localToWorldMatrices == null || localToWorldMatrices.Length != spriteBoneDataList.Count)
+                localToWorldMatrices = new Matrix4x4[spriteBoneDataList.Count];
+
+            bool[] calculatedMatrix = new bool[spriteBoneDataList.Count];
+
+            var processedBoneCount = 0;
+            while (processedBoneCount < spriteBoneDataList.Count)
+            {
+                int oldCount = processedBoneCount;
+
+                for (var i = 0; i < spriteBoneDataList.Count; ++i)
+                {
+                    if (calculatedMatrix[i])
+                        continue;
+
+                    var sourceBone = spriteBoneDataList[i];
+                    if (sourceBone.parentId != -1 && !calculatedMatrix[sourceBone.parentId])
+                        continue;
+
+                    var localToWorldMatrix = Matrix4x4.identity;
+                    localToWorldMatrix.SetTRS(sourceBone.localPosition, sourceBone.localRotation, Vector3.one);
+
+                    if (sourceBone.parentId == -1)
+                        localToWorldMatrix = rootMatrix * localToWorldMatrix;
+                    else if (calculatedMatrix[sourceBone.parentId])
+                        localToWorldMatrix = localToWorldMatrices[sourceBone.parentId] * localToWorldMatrix;
+
+                    localToWorldMatrices[i] = localToWorldMatrix;
+                    calculatedMatrix[i] = true;
+                    processedBoneCount++;
+                }
+
+                if (oldCount == processedBoneCount)
+                    throw new ArgumentException("Invalid hierarchy detected");
+            }
+        }
+
+        public static List<SpriteBoneData> CreateSpriteBoneData(UnityEngine.U2D.SpriteBone[] spriteBoneList, Matrix4x4 rootMatrix)
+        {
+            List<SpriteBoneData> spriteBoneDataList = new List<SpriteBoneData>(spriteBoneList.Length);
+
+            foreach (var spriteBone in spriteBoneList)
+            {
+                spriteBoneDataList.Add(new SpriteBoneData()
+                {
+                    name = spriteBone.name,
+                    parentId = spriteBone.parentId,
+                    localPosition = spriteBone.position,
+                    localRotation = spriteBone.rotation,
+                    depth = spriteBone.position.z,
+                    length = spriteBone.length
+                });
+            }
+
+            Matrix4x4[] localToWorldMatrices = null;
+            UpdateLocalToWorldMatrices(spriteBoneDataList, rootMatrix, ref localToWorldMatrices);
+
+            for (int i = 0; i < spriteBoneDataList.Count; ++i)
+            {
+                var spriteBoneData = spriteBoneDataList[i];
+                spriteBoneData.position = localToWorldMatrices[i].MultiplyPoint(Vector2.zero);
+                spriteBoneData.endPosition = localToWorldMatrices[i].MultiplyPoint(Vector2.right * spriteBoneData.length);
+            }
+
+            return spriteBoneDataList;
+        }
+    }
+}

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

@@ -0,0 +1,570 @@
+using UnityEngine;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using UnityEditor.U2D.Sprites;
+
+namespace UnityEditor.U2D.Animation
+{
+    [RequireSpriteDataProvider(typeof(ISpriteMeshDataProvider), typeof(ISpriteBoneDataProvider))]
+    internal partial class SkinningModule : SpriteEditorModuleBase
+    {
+        private static class Styles
+        {
+            public static string moduleName = L10n.Tr("Skinning Editor");
+        }
+
+        private SkinningCache m_SkinningCache;
+        private int m_PrevNearestControl = -1;
+        private SpriteOutlineRenderer m_SpriteOutlineRenderer;
+        private MeshPreviewTool m_MeshPreviewTool;
+        private SkinningMode m_PreviousSkinningMode;
+        private SpriteBoneInfluenceTool m_CharacterSpriteTool;
+        private HorizontalToggleTools m_HorizontalToggleTools;
+        private AnimationAnalytics m_Analytics;
+        private ModuleToolGroup m_ModuleToolGroup;
+        IMeshPreviewBehaviour m_MeshPreviewBehaviourOverride = null;
+        bool m_CollapseToolbar;
+
+        internal SkinningCache skinningCache
+        {
+            get { return m_SkinningCache; }
+        }
+
+        private BaseTool currentTool
+        {
+            get { return skinningCache.selectedTool; }
+            set { skinningCache.selectedTool = value; }
+        }
+
+        public override string moduleName
+        {
+            get { return Styles.moduleName; }
+        }
+
+        public override void OnModuleActivate()
+        {
+            m_SkinningCache = Cache.Create<SkinningCache>();
+
+            AddMainUI(spriteEditor.GetMainVisualContainer());
+
+            using (skinningCache.DisableUndoScope())
+            {
+                skinningCache.Create(spriteEditor, SkinningCachePersistentState.instance);
+                skinningCache.CreateToolCache(spriteEditor, m_LayoutOverlay);
+                m_CharacterSpriteTool = skinningCache.CreateTool<SpriteBoneInfluenceTool>();
+                m_CharacterSpriteTool.Initialize(m_LayoutOverlay);
+                m_MeshPreviewTool = skinningCache.CreateTool<MeshPreviewTool>();
+                SetupModuleToolGroup();
+                m_MeshPreviewTool.Activate();
+
+                m_SpriteOutlineRenderer = new SpriteOutlineRenderer(spriteEditor, skinningCache.events);
+
+                spriteEditor.enableMouseMoveEvent = true;
+
+                Undo.undoRedoPerformed += UndoRedoPerformed;
+                skinningCache.events.skeletonTopologyChanged.AddListener(SkeletonTopologyChanged);
+                skinningCache.events.skeletonPreviewPoseChanged.AddListener(SkeletonPreviewPoseChanged);
+                skinningCache.events.skeletonBindPoseChanged.AddListener(SkeletonBindPoseChanged);
+                skinningCache.events.characterPartChanged.AddListener(CharacterPartChanged);
+                skinningCache.events.skinningModeChanged.AddListener(OnViewModeChanged);
+                skinningCache.events.meshChanged.AddListener(OnMeshChanged);
+                skinningCache.events.boneNameChanged.AddListener(OnBoneNameChanged);
+                skinningCache.events.boneDepthChanged.AddListener(OnBoneDepthChanged);
+                skinningCache.events.spriteLibraryChanged.AddListener(OnSpriteLibraryChanged);
+                skinningCache.events.meshPreviewBehaviourChange.AddListener(OnMeshPreviewBehaviourChange);
+
+                skinningCache.RestoreFromPersistentState();
+                ActivateTool(skinningCache.selectedTool);
+                skinningCache.RestoreToolStateFromPersistentState();
+
+                // Set state for Switch Mode tool
+                m_PreviousSkinningMode = skinningCache.mode;
+                if (skinningCache.mode == SkinningMode.Character)
+                {
+                    skinningCache.GetTool(Tools.SwitchMode).Deactivate();
+                }
+                else
+                {
+                    skinningCache.GetTool(Tools.SwitchMode).Activate();
+                }
+                SetupSpriteEditor(true);
+
+                m_HorizontalToggleTools = new HorizontalToggleTools(skinningCache)
+                {
+                    onActivateTool = (b) =>
+                    {
+                        using (skinningCache.UndoScope(TextContent.setTool))
+                        {
+                            ActivateTool(b);
+                        }
+                    }
+                };
+
+                var ai = spriteEditor.GetDataProvider<ISpriteEditorDataProvider>() as AssetImporter;
+                m_Analytics = new AnimationAnalytics(new UnityAnalyticsStorage(),
+                    skinningCache.events,
+                    new SkinningModuleAnalyticsModel(skinningCache),
+                    ai ==  null ? -1 : ai.GetInstanceID());
+
+                UpdateCollapseToolbar();
+            }
+        }    
+  
+        public override void OnModuleDeactivate()
+        {
+            if (m_SpriteOutlineRenderer != null)
+                m_SpriteOutlineRenderer.Dispose();
+
+            spriteEditor.enableMouseMoveEvent = false;
+
+            Undo.undoRedoPerformed -= UndoRedoPerformed;
+            skinningCache.events.skeletonTopologyChanged.RemoveListener(SkeletonTopologyChanged);
+            skinningCache.events.skeletonPreviewPoseChanged.RemoveListener(SkeletonPreviewPoseChanged);
+            skinningCache.events.skeletonBindPoseChanged.RemoveListener(SkeletonBindPoseChanged);
+            skinningCache.events.characterPartChanged.RemoveListener(CharacterPartChanged);
+            skinningCache.events.skinningModeChanged.RemoveListener(OnViewModeChanged);
+            skinningCache.events.meshChanged.RemoveListener(OnMeshChanged);
+            skinningCache.events.boneNameChanged.RemoveListener(OnBoneNameChanged);
+            skinningCache.events.boneDepthChanged.RemoveListener(OnBoneDepthChanged);
+            skinningCache.events.spriteLibraryChanged.RemoveListener(OnSpriteLibraryChanged);
+            skinningCache.events.meshPreviewBehaviourChange.RemoveListener(OnMeshPreviewBehaviourChange);
+
+            RemoveMainUI(spriteEditor.GetMainVisualContainer());
+            RestoreSpriteEditor();
+            m_Analytics.Dispose();
+            m_Analytics = null;
+
+            Cache.Destroy(m_SkinningCache);
+        }
+
+        private void UpdateCollapseToolbar()
+        {
+            m_CollapseToolbar = SkinningModuleSettings.compactToolBar;
+            m_WeightToolbar.CollapseToolBar(m_CollapseToolbar);
+            m_MeshToolbar.CollapseToolBar(m_CollapseToolbar);
+            m_BoneToolbar.CollapseToolBar(m_CollapseToolbar);
+            m_LayoutOverlay.verticalToolbar.Collapse(m_CollapseToolbar);
+            m_HorizontalToggleTools.collapseToolbar = m_CollapseToolbar;
+        }
+
+        private void OnBoneNameChanged(BoneCache bone)
+        {
+            var character = skinningCache.character;
+
+            if (character != null && character.skeleton == bone.skeleton)
+                skinningCache.SyncSpriteSheetSkeletons();
+            DataModified();
+        }
+
+        private void OnBoneDepthChanged(BoneCache bone)
+        {
+            var sprites = skinningCache.GetSprites();
+            var controller = new SpriteMeshDataController();
+
+            foreach (var sprite in sprites)
+            {
+                var mesh = sprite.GetMesh();
+
+                if (mesh.ContainsBone(bone))
+                {
+                    controller.spriteMeshData = mesh;
+                    controller.SortTrianglesByDepth();
+                    skinningCache.events.meshChanged.Invoke(mesh);
+                }
+            }
+
+            DataModified();
+        }
+
+        private void OnMeshChanged(MeshCache mesh)
+        {
+            DataModified();
+        }
+
+        private void DataModified()
+        {
+            spriteEditor.SetDataModified();
+        }
+
+        private void OnViewModeChanged(SkinningMode mode)
+        {
+            SetupSpriteEditor();
+        }
+
+        private void SetupSpriteEditor(bool setPreviewTexture = false)
+        {
+            var textureProvider = spriteEditor.GetDataProvider<ITextureDataProvider>();
+            if (textureProvider == null)
+                return;
+
+            var emptyTexture = new Texture2D(1, 1, TextureFormat.RGBAHalf, false, true);
+            emptyTexture.hideFlags = HideFlags.HideAndDontSave;
+            emptyTexture.SetPixel(1, 1, new Color(0, 0, 0, 0));
+            emptyTexture.Apply();
+
+            int width = 0, height = 0;
+            if (skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                textureProvider.GetTextureActualWidthAndHeight(out width, out height);
+            }
+            else
+            {
+                width = skinningCache.character.dimension.x;
+                height = skinningCache.character.dimension.y;
+            }
+
+            if (m_PreviousSkinningMode != skinningCache.mode || setPreviewTexture)
+            {
+                spriteEditor.SetPreviewTexture(emptyTexture, width, height);
+                if (m_PreviousSkinningMode != skinningCache.mode)
+                {
+                    m_PreviousSkinningMode = skinningCache.mode;
+                    spriteEditor.ResetZoomAndScroll();
+                }
+            }
+
+            spriteEditor.spriteRects = new List<SpriteRect>();
+        }
+
+        private void RestoreSpriteEditor()
+        {
+            var textureProvider = spriteEditor.GetDataProvider<ITextureDataProvider>();
+
+            if (textureProvider != null)
+            {
+                int width, height;
+                textureProvider.GetTextureActualWidthAndHeight(out width, out height);
+
+                var texture = textureProvider.previewTexture;
+                spriteEditor.SetPreviewTexture(texture, width, height);
+            }
+
+            var spriteRectProvider = spriteEditor.GetDataProvider<ISpriteEditorDataProvider>();
+
+            if (spriteRectProvider != null)
+                spriteEditor.spriteRects = new List<SpriteRect>(spriteRectProvider.GetSpriteRects());
+        }
+
+        public override bool CanBeActivated()
+        {
+            var dataProvider = spriteEditor.GetDataProvider<ISpriteEditorDataProvider>();
+            return dataProvider == null ? false : dataProvider.spriteImportMode != SpriteImportMode.None;
+        }
+
+        public override void DoPostGUI()
+        {
+            if (!spriteEditor.windowDimension.Contains(Event.current.mousePosition))
+                HandleUtility.nearestControl = 0;
+
+            if (Event.current.type == EventType.Layout && m_PrevNearestControl != HandleUtility.nearestControl)
+            {
+                m_PrevNearestControl = HandleUtility.nearestControl;
+                spriteEditor.RequestRepaint();
+            }
+
+            skinningCache.EndUndoOperation();
+        }
+
+        public override void DoMainGUI()
+        {
+            Debug.Assert(currentTool != null);
+
+            DoViewGUI();
+
+            if (!spriteEditor.editingDisabled)
+                skinningCache.selectionTool.DoGUI();
+
+            m_MeshPreviewTool.previewBehaviourOverride = m_MeshPreviewBehaviourOverride != null ? m_MeshPreviewBehaviourOverride : currentTool.previewBehaviour;
+            m_MeshPreviewTool.DoGUI();
+            m_MeshPreviewTool.DrawOverlay();
+
+            m_SpriteOutlineRenderer.RenderSpriteOutline(spriteEditor, skinningCache.selectedSprite);
+
+            m_MeshPreviewTool.OverlayWireframe();
+
+            if (!spriteEditor.editingDisabled)
+            {
+                currentTool.DoGUI();
+                DoCopyPasteKeyboardEventHandling();
+            }
+
+            DrawRectGizmos();
+
+            if (SkinningModuleSettings.compactToolBar != m_CollapseToolbar)
+                UpdateCollapseToolbar();
+        }
+
+        public override void DoToolbarGUI(Rect drawArea)
+        {
+            m_HorizontalToggleTools.DoGUI(drawArea, currentTool, spriteEditor.editingDisabled);
+        }
+
+        void DoCopyPasteKeyboardEventHandling()
+        {
+            var evt = Event.current;
+            if (evt.type == EventType.ValidateCommand)
+            {
+                if (evt.commandName == "Copy" || evt.commandName == "Paste")
+                    evt.Use();
+                return;
+            }
+
+            if (evt.type == EventType.ExecuteCommand)
+            {
+                var copyTool = skinningCache.GetTool(Tools.CopyPaste) as CopyTool;
+                if (copyTool != null && evt.commandName == "Copy")
+                {
+                    copyTool.OnCopyActivated();
+                    evt.Use();
+                }
+                else if (copyTool != null && evt.commandName == "Paste")
+                {
+                    copyTool.OnPasteActivated(true, true, false, false);
+                    evt.Use();
+                }
+            }
+        }
+
+        private void DrawRectGizmos()
+        {
+            if (Event.current.type == EventType.Repaint)
+            {
+                var selectedSprite = skinningCache.selectedSprite;
+                var sprites = skinningCache.GetSprites();
+                var unselectedRectColor = new Color(1f, 1f, 1f, 0.5f);
+
+                foreach (var sprite in sprites)
+                {
+                    var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
+
+                    Debug.Assert(skeleton != null);
+
+                    if (skeleton.isPosePreview)
+                        continue;
+
+                    var color = unselectedRectColor;
+
+                    if (sprite == selectedSprite)
+                        color = DrawingUtility.kSpriteBorderColor;
+
+                    if (skinningCache.mode == SkinningMode.Character
+                        && sprite != selectedSprite)
+                        continue;
+
+                    var matrix = sprite.GetLocalToWorldMatrixFromMode();
+                    var rect = new Rect(matrix.MultiplyPoint3x4(Vector3.zero), sprite.textureRect.size);
+
+                    DrawingUtility.BeginLines(color);
+                    DrawingUtility.DrawBox(rect);
+                    DrawingUtility.EndLines();
+                }
+            }
+        }
+
+        private void UndoRedoPerformed()
+        {
+            using (new DisableUndoScope(skinningCache))
+            {
+                UpdateToggleState();
+                skinningCache.UndoRedoPerformed();
+                SetupSpriteEditor();
+            }
+        }
+
+        #region CharacterConsistency
+        //TODO: Bring this to a better place, maybe CharacterController
+        private void SkeletonPreviewPoseChanged(SkeletonCache skeleton)
+        {
+            var character = skinningCache.character;
+
+            if (character != null && character.skeleton == skeleton)
+                skinningCache.SyncSpriteSheetSkeletons();
+        }
+
+        private void SkeletonBindPoseChanged(SkeletonCache skeleton)
+        {
+            var character = skinningCache.character;
+
+            if (character != null && character.skeleton == skeleton)
+                skinningCache.SyncSpriteSheetSkeletons();
+            DataModified();
+        }
+
+        private void SkeletonTopologyChanged(SkeletonCache skeleton)
+        {
+            var character = skinningCache.character;
+
+            if (character == null)
+            {
+                var sprite = FindSpriteFromSkeleton(skeleton);
+
+                Debug.Assert(sprite != null);
+
+                sprite.UpdateMesh(skeleton.bones);
+
+                DataModified();
+            }
+            else if (character.skeleton == skeleton)
+            {
+                skinningCache.CreateSpriteSheetSkeletons();
+                DataModified();
+            }
+        }
+
+        private void CharacterPartChanged(CharacterPartCache characterPart)
+        {
+            var character = skinningCache.character;
+
+            Debug.Assert(character != null);
+
+            using (new DefaultPoseScope(character.skeleton))
+            {
+                skinningCache.CreateSpriteSheetSkeleton(characterPart);
+                DataModified();
+            }
+
+            if (skinningCache.mode == SkinningMode.Character)
+                characterPart.SyncSpriteSheetSkeleton();
+        }
+
+        private SpriteCache FindSpriteFromSkeleton(SkeletonCache skeleton)
+        {
+            var sprites = skinningCache.GetSprites();
+            return sprites.FirstOrDefault(sprite => sprite.GetSkeleton() == skeleton);
+        }
+
+        #endregion
+
+        public override bool ApplyRevert(bool apply)
+        {
+            if (apply)
+            {
+                m_Analytics.FlushEvent();
+                skinningCache.applyingChanges = true;
+                skinningCache.RestoreBindPose();
+                ApplyBone();
+                ApplyMesh();
+                ApplyCharacter();
+                skinningCache.applyingChanges = false;
+                DoApplyAnalytics();
+            }
+            else
+                skinningCache.Revert();
+            return true;
+        }
+
+        private void DoApplyAnalytics()
+        {
+            var sprites = skinningCache.GetSprites();
+            var spriteBoneCount = sprites.Select(s => s.GetSkeleton().BoneCount).ToArray();
+            BoneCache[] bones = null;
+
+            if (skinningCache.hasCharacter)
+                bones = skinningCache.character.skeleton.bones;
+            else
+                bones = sprites.SelectMany(s => s.GetSkeleton().bones).ToArray();
+
+            m_Analytics.SendApplyEvent(sprites.Length, spriteBoneCount, bones);
+        }
+
+        private void ApplyBone()
+        {
+            var boneDataProvider = spriteEditor.GetDataProvider<ISpriteBoneDataProvider>();
+            if (boneDataProvider != null)
+            {
+                var sprites = skinningCache.GetSprites();
+                foreach (var sprite in sprites)
+                {
+                    var bones = sprite.GetSkeleton().bones;
+                    boneDataProvider.SetBones(new GUID(sprite.id), bones.ToSpriteBone(sprite.localToWorldMatrix).ToList());
+                }
+            }
+        }
+
+        private void ApplyMesh()
+        {
+            var meshDataProvider = spriteEditor.GetDataProvider<ISpriteMeshDataProvider>();
+            if (meshDataProvider != null)
+            {
+                var sprites = skinningCache.GetSprites();
+                foreach (var sprite in sprites)
+                {
+                    var mesh = sprite.GetMesh();
+                    var guid = new GUID(sprite.id);
+                    meshDataProvider.SetVertices(guid, mesh.vertices.Select(x =>
+                        new Vertex2DMetaData()
+                        {
+                            boneWeight = x.editableBoneWeight.ToBoneWeight(false),
+                            position = x.position
+                        }
+                        ).ToArray());
+                    meshDataProvider.SetIndices(guid, mesh.indices.ToArray());
+                    meshDataProvider.SetEdges(guid, mesh.edges.Select(x => new Vector2Int(x.index1, x.index2)).ToArray());
+                }
+            }
+        }
+
+        private void ApplyCharacter()
+        {
+            var characterDataProvider = spriteEditor.GetDataProvider<ICharacterDataProvider>();
+            var character = skinningCache.character;
+            if (characterDataProvider != null && character != null)
+            {
+                var data = new CharacterData();
+                var characterBones = character.skeleton.bones;
+                data.bones = characterBones.ToSpriteBone(Matrix4x4.identity);
+
+                var parts = character.parts;
+                data.parts = parts.Select(x =>
+                    new CharacterPart()
+                    {
+                        spriteId = x.sprite.id,
+                        spritePosition = new RectInt((int)x.position.x, (int)x.position.y, (int)x.sprite.textureRect.width, (int)x.sprite.textureRect.height),
+                        bones = x.bones.Select(bone => Array.IndexOf(characterBones, bone)).ToArray()
+                    }
+                    ).ToArray();
+
+                characterDataProvider.SetCharacterData(data);
+            }
+
+            var spriteLibDataProvider = spriteEditor.GetDataProvider<ISpriteLibDataProvider>();
+            if (spriteLibDataProvider != null)
+            {
+                spriteLibDataProvider.SetSpriteCategoryList(skinningCache.spriteCategoryList.ToSpriteLibrary());
+            }
+        }
+
+        void OnSpriteLibraryChanged()
+        {
+            DataModified();
+        }
+
+
+        void OnMeshPreviewBehaviourChange(IMeshPreviewBehaviour meshPreviewBehaviour)
+        {
+            m_MeshPreviewBehaviourOverride = meshPreviewBehaviour;
+        }
+
+        private void SetupModuleToolGroup()
+        {
+            m_ModuleToolGroup = new ModuleToolGroup();
+            m_ModuleToolGroup.AddToolToGroup(0, skinningCache.GetTool(Tools.Visibility), null);
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.EditGeometry), () => currentTool = skinningCache.GetTool(Tools.EditGeometry));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.CreateVertex), () => currentTool = skinningCache.GetTool(Tools.CreateVertex));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.CreateEdge), () => currentTool = skinningCache.GetTool(Tools.CreateEdge));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.SplitEdge), () => currentTool = skinningCache.GetTool(Tools.SplitEdge));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.GenerateGeometry), () => currentTool = skinningCache.GetTool(Tools.GenerateGeometry));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.EditPose), () => currentTool = skinningCache.GetTool(Tools.EditPose));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.EditJoints), () => currentTool = skinningCache.GetTool(Tools.EditJoints));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.CreateBone), () => currentTool = skinningCache.GetTool(Tools.CreateBone));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.SplitBone), () => currentTool = skinningCache.GetTool(Tools.SplitBone));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.WeightSlider), () => currentTool = skinningCache.GetTool(Tools.WeightSlider));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.WeightBrush), () => currentTool = skinningCache.GetTool(Tools.WeightBrush));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.GenerateWeights), () => currentTool = skinningCache.GetTool(Tools.GenerateWeights));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.BoneInfluence), () => currentTool = skinningCache.GetTool(Tools.BoneInfluence));
+            m_ModuleToolGroup.AddToolToGroup(1, skinningCache.GetTool(Tools.CopyPaste), () => currentTool = skinningCache.GetTool(Tools.CopyPaste));
+        }
+    }
+}
+

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 92be5a949cc9a014dbcb41d98e5aec03
+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/SkinningModuleView.cs

@@ -0,0 +1,394 @@
+using System;
+using UnityEditor.U2D.Common;
+using UnityEditor.U2D.Layout;
+using UnityEngine;
+using UnityEditor.ShortcutManagement;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal partial class SkinningModule
+    {
+        private LayoutOverlay m_LayoutOverlay;
+        private BoneToolbar m_BoneToolbar;
+        private MeshToolbar m_MeshToolbar;
+        private WeightToolbar m_WeightToolbar;
+
+        private InternalEditorBridge.ShortcutContext m_ShortcutContext;
+
+        private static SkinningModule GetModuleFromContext(ShortcutArguments args)
+        {
+            var sc = args.context as InternalEditorBridge.ShortcutContext;
+            if (sc == null)
+                return null;
+
+            return sc.context as SkinningModule;
+        }
+
+        [Shortcut("2D/Animation/Toggle Tool Text", typeof(InternalEditorBridge.ShortcutContext), KeyCode.BackQuote, ShortcutModifiers.Shift)]
+        private static void CollapseToolbar(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null)
+            {
+                SkinningModuleSettings.compactToolBar = !SkinningModuleSettings.compactToolBar;
+            }
+        }
+
+        [Shortcut("2D/Animation/Restore Bind Pose", typeof(InternalEditorBridge.ShortcutContext), KeyCode.Alpha1, ShortcutModifiers.Shift)]
+        private static void DisablePoseModeKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                var effectiveSkeleton = sm.skinningCache.GetEffectiveSkeleton(sm.skinningCache.selectedSprite);
+                if (effectiveSkeleton != null && effectiveSkeleton.isPosePreview)
+                {
+                    using (sm.skinningCache.UndoScope(TextContent.restorePose))
+                    {
+                        sm.skinningCache.RestoreBindPose();
+                        sm.skinningCache.events.shortcut.Invoke("#1");
+                    }   
+                }
+            }
+        }
+
+        [Shortcut("2D/Animation/Toggle Character Mode", typeof(InternalEditorBridge.ShortcutContext), KeyCode.Alpha2, ShortcutModifiers.Shift)]
+        private static void ToggleCharacterModeKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.hasCharacter)
+            {
+                var tool = sm.skinningCache.GetTool(Tools.SwitchMode);
+
+                using (sm.skinningCache.UndoScope(TextContent.setMode))
+                {
+                    if (tool.isActive)
+                        tool.Deactivate();
+                    else
+                        tool.Activate();
+                }
+
+                sm.skinningCache.events.shortcut.Invoke("#2");
+            }
+        }
+
+        [Shortcut("2D/Animation/Preview Pose", typeof(InternalEditorBridge.ShortcutContext), KeyCode.Q, ShortcutModifiers.Shift)]
+        private static void EditPoseKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetSkeletonTool(Tools.EditPose);
+                sm.skinningCache.events.shortcut.Invoke("#q");
+            }
+        }
+
+        [Shortcut("2D/Animation/Edit Bone", typeof(InternalEditorBridge.ShortcutContext), KeyCode.W, ShortcutModifiers.Shift)]
+        private static void EditJointsKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetSkeletonTool(Tools.EditJoints);
+                sm.skinningCache.events.shortcut.Invoke("#w");
+            }
+        }
+
+        [Shortcut("2D/Animation/Create Bone", typeof(InternalEditorBridge.ShortcutContext), KeyCode.E, ShortcutModifiers.Shift)]
+        private static void CreateBoneKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetSkeletonTool(Tools.CreateBone);
+                sm.skinningCache.events.shortcut.Invoke("#e");
+            }
+        }
+
+        [Shortcut("2D/Animation/Split Bone", typeof(InternalEditorBridge.ShortcutContext), KeyCode.R, ShortcutModifiers.Shift)]
+        private static void SplitBoneKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetSkeletonTool(Tools.SplitBone);
+                sm.skinningCache.events.shortcut.Invoke("#r");
+            }
+        }
+
+        [Shortcut("2D/Animation/Auto Geometry", typeof(InternalEditorBridge.ShortcutContext), KeyCode.A, ShortcutModifiers.Shift)]
+        private static void GenerateGeometryKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetMeshTool(Tools.GenerateGeometry);
+                sm.skinningCache.events.shortcut.Invoke("#a");
+            }
+        }
+
+        [Shortcut("2D/Animation/Edit Geometry", typeof(InternalEditorBridge.ShortcutContext), KeyCode.S, ShortcutModifiers.Shift)]
+        private static void MeshSelectionKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetMeshTool(Tools.EditGeometry);
+                sm.skinningCache.events.shortcut.Invoke("#s");
+            }
+        }
+
+        [Shortcut("2D/Animation/Create Vertex", typeof(InternalEditorBridge.ShortcutContext), KeyCode.J, ShortcutModifiers.Shift)]
+        private static void CreateVertex(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetMeshTool(Tools.CreateVertex);
+                sm.skinningCache.events.shortcut.Invoke("#d");
+            }
+        }
+
+        [Shortcut("2D/Animation/Create Edge", typeof(InternalEditorBridge.ShortcutContext), KeyCode.G, ShortcutModifiers.Shift)]
+        private static void CreateEdgeKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetMeshTool(Tools.CreateEdge);
+                sm.skinningCache.events.shortcut.Invoke("#g");
+            }
+        }
+
+        [Shortcut("2D/Animation/Split Edge", typeof(InternalEditorBridge.ShortcutContext), KeyCode.H, ShortcutModifiers.Shift)]
+        private static void SplitEdge(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetMeshTool(Tools.SplitEdge);
+                sm.skinningCache.events.shortcut.Invoke("#h");
+            }
+        }
+
+        [Shortcut("2D/Animation/Auto Weights", typeof(InternalEditorBridge.ShortcutContext), KeyCode.Z, ShortcutModifiers.Shift)]
+        private static void GenerateWeightsKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetWeightTool(Tools.GenerateWeights);
+                sm.skinningCache.events.shortcut.Invoke("#z");
+            }
+        }
+
+        [Shortcut("2D/Animation/Weight Slider", typeof(InternalEditorBridge.ShortcutContext), KeyCode.X, ShortcutModifiers.Shift)]
+        private static void WeightSliderKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetWeightTool(Tools.WeightSlider);
+                sm.skinningCache.events.shortcut.Invoke("#x");
+            }
+        }
+
+        [Shortcut("2D/Animation/Weight Brush", typeof(InternalEditorBridge.ShortcutContext), KeyCode.N, ShortcutModifiers.Shift)]
+        private static void WeightBrushKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.SetWeightTool(Tools.WeightBrush);
+                sm.skinningCache.events.shortcut.Invoke("#c");
+            }
+        }
+
+        [Shortcut("2D/Animation/Bone Influence", typeof(InternalEditorBridge.ShortcutContext), KeyCode.V, ShortcutModifiers.Shift)]
+        private static void BoneInfluenceKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.mode == SkinningMode.Character)
+            {
+                sm.SetWeightTool(Tools.BoneInfluence);
+                sm.skinningCache.events.shortcut.Invoke("#v");
+            }
+        }
+
+        [Shortcut("2D/Animation/Paste Panel Weights", typeof(InternalEditorBridge.ShortcutContext), KeyCode.B, ShortcutModifiers.Shift)]
+        private static void PastePanelKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.m_HorizontalToggleTools.TogglePasteTool(sm.currentTool);
+                sm.skinningCache.events.shortcut.Invoke("#b");
+            }
+        }
+
+        [Shortcut("2D/Animation/Visibility Panel", typeof(InternalEditorBridge.ShortcutContext), KeyCode.P, ShortcutModifiers.Shift)]
+        private static void VisibilityPanelKey(ShortcutArguments args)
+        {
+            var sm = GetModuleFromContext(args);
+            if (sm != null && !sm.spriteEditor.editingDisabled)
+            {
+                sm.m_HorizontalToggleTools.ToggleVisibilityTool(sm.currentTool);
+                sm.skinningCache.events.shortcut.Invoke("#p");
+            }
+        }
+
+        private void AddMainUI(VisualElement mainView)
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("LayoutOverlay/LayoutOverlay.uxml");
+            VisualElement clone = visualTree.CloneTree();
+            m_LayoutOverlay = clone.Q<LayoutOverlay>("LayoutOverlay");
+
+            mainView.Add(m_LayoutOverlay);
+            m_LayoutOverlay.hasScrollbar = true;
+            m_LayoutOverlay.StretchToParentSize();
+
+            CreateBoneToolbar();
+            CreateMeshToolbar();
+            CreateWeightToolbar();
+
+            m_ShortcutContext = new InternalEditorBridge.ShortcutContext()
+            {
+                isActive = isFocused,
+                context = this
+            };
+            InternalEditorBridge.RegisterShortcutContext(m_ShortcutContext);
+            InternalEditorBridge.AddEditorApplicationProjectLoadedCallback(OnProjectLoaded);
+        }
+
+        private void OnProjectLoaded()
+        {
+            if (m_ShortcutContext != null)
+                InternalEditorBridge.RegisterShortcutContext(m_ShortcutContext);
+        }
+        
+        private void DoViewGUI()
+        {
+            if (spriteEditor.editingDisabled == m_BoneToolbar.enabledSelf)
+            {
+                m_BoneToolbar.SetEnabled(!spriteEditor.editingDisabled);
+                m_MeshToolbar.SetEnabled(!spriteEditor.editingDisabled);
+                m_WeightToolbar.SetEnabled(!spriteEditor.editingDisabled);
+            }
+
+            if (spriteEditor.editingDisabled == m_LayoutOverlay.rightOverlay.enabledSelf)
+            {
+                m_LayoutOverlay.rightOverlay.SetEnabled(!spriteEditor.editingDisabled);
+                m_LayoutOverlay.rightOverlay.visible = !spriteEditor.editingDisabled;
+            }
+        }
+
+        private bool isFocused()
+        {
+            return spriteEditor != null && (EditorWindow.focusedWindow == spriteEditor as EditorWindow);
+        }
+
+        private void CreateBoneToolbar()
+        {
+            m_BoneToolbar = BoneToolbar.GenerateFromUXML();
+            m_BoneToolbar.Setup(skinningCache);
+            m_LayoutOverlay.verticalToolbar.AddToContainer(m_BoneToolbar);
+
+            m_BoneToolbar.SetSkeletonTool += SetSkeletonTool;
+            m_BoneToolbar.SetEnabled(!spriteEditor.editingDisabled);
+        }
+
+        private void CreateMeshToolbar()
+        {
+            m_MeshToolbar = MeshToolbar.GenerateFromUXML();
+            m_MeshToolbar.skinningCache = skinningCache;
+            m_LayoutOverlay.verticalToolbar.AddToContainer(m_MeshToolbar);
+
+            m_MeshToolbar.SetMeshTool += SetMeshTool;
+            m_MeshToolbar.SetEnabled(!spriteEditor.editingDisabled);
+        }
+
+        private void CreateWeightToolbar()
+        {
+            m_WeightToolbar = WeightToolbar.GenerateFromUXML();
+            m_WeightToolbar.skinningCache = skinningCache;
+            m_LayoutOverlay.verticalToolbar.AddToContainer(m_WeightToolbar);
+            m_WeightToolbar.SetWeightTool += SetWeightTool;
+            m_WeightToolbar.SetEnabled(!spriteEditor.editingDisabled);
+        }
+
+        private void SetSkeletonTool(Tools toolType)
+        {
+            var tool = skinningCache.GetTool(toolType) as SkeletonToolWrapper;
+
+            if (currentTool == tool)
+                return;
+
+            using (skinningCache.UndoScope(TextContent.setTool))
+            {
+                ActivateTool(tool);
+
+                if (tool.editBindPose)
+                    skinningCache.RestoreBindPose();
+            }
+        }
+
+        private void SetMeshTool(Tools toolType)
+        {
+            var tool  = skinningCache.GetTool(toolType);
+
+            if (currentTool == tool)
+                return;
+
+            using (skinningCache.UndoScope(TextContent.setTool))
+            {
+                ActivateTool(tool);
+                skinningCache.RestoreBindPose();
+                UnselectBones();
+            }
+        }
+
+        private void SetWeightTool(Tools toolType)
+        {
+            var tool = skinningCache.GetTool(toolType);
+
+            if (currentTool == tool)
+                return;
+
+            using (skinningCache.UndoScope(TextContent.setTool))
+            {
+                ActivateTool(tool);
+            }
+        }
+
+        private void ActivateTool(BaseTool tool)
+        {
+            m_ModuleToolGroup.ActivateTool(tool);
+            UpdateToggleState();
+            skinningCache.events.toolChanged.Invoke(tool);
+        }
+
+        private void UnselectBones()
+        {
+            skinningCache.skeletonSelection.Clear();
+            skinningCache.events.boneSelectionChanged.Invoke();
+        }
+
+        private void UpdateToggleState()
+        {
+            Debug.Assert(m_BoneToolbar != null);
+            Debug.Assert(m_MeshToolbar != null);
+            Debug.Assert(m_WeightToolbar != null);
+
+            m_BoneToolbar.UpdateToggleState();
+            m_MeshToolbar.UpdateToggleState();
+            m_WeightToolbar.UpdateToggleState();
+        }
+
+        private void RemoveMainUI(VisualElement mainView)
+        {
+            InternalEditorBridge.RemoveEditorApplicationProjectLoadedCallback(OnProjectLoaded);
+            InternalEditorBridge.UnregisterShortcutContext(m_ShortcutContext);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4ddf280179469e548a5aff8e5eec973c
+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/SkinningSerializer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6a526b93b1b26d040a197bb4ffe84ba1
+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/SpriteBoneInfluence.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ae8222a77d2168b45b8a300c2ae1300b
+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/SpriteMeshData.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 100c104341c6bfd4e824d8347fff1f87
+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/TextContent.cs

@@ -0,0 +1,107 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class TextContent
+    {
+        // Undo
+        public static string setMode = "Set Mode";
+        public static string setTool = "Set Tool";
+        public static string pasteData = "Paste Data";
+        public static string generateGeometry = "Generate Geometry";
+        public static string generateWeights = "Generate Weights";
+        public static string normalizeWeights = "Normalize Weights";
+        public static string clearWeights = "Clear Weights";
+        public static string restorePose = "Restore Pose";
+        public static string selection = "Selection";
+        public static string clearSelection = "Clear Selection";
+        public static string editWeights = "Edit Weights";
+        public static string boneName = "Bone Name";
+        public static string boneDepth = "Bone Depth";
+        public static string rotateBone = "Rotate Bone";
+        public static string moveBone = "Move Bone";
+        public static string freeMoveBone = "Free Move Bone";
+        public static string moveJoint = "Move Joint";
+        public static string moveEndPoint = "Move End Point";
+        public static string boneLength = "Bone Length";
+        public static string createBone = "Create Bone";
+        public static string splitBone = "Split Bone";
+        public static string removeBone = "Remove Bone";
+        public static string moveVertices = "Move Vertices";
+        public static string createVertex = "Create Vertex";
+        public static string createEdge = "Create Edge";
+        public static string splitEdge = "Split Edge";
+        public static string removeEdge = "Remove Edge";
+        public static string removeVertices = "Remove Vertices";
+        public static string selectionChange = "Selection Change";
+        public static string boneVisibility = "Bone Visibility";
+        public static string setParentBone = "Set Parent Bone";
+        public static string visibilityChange = "VisibilityChange";
+        public static string boneSelection = "Bone Selection";
+        public static string expandBones = "Expand Bones";
+        public static string meshVisibility = "Mesh Visibility";
+        public static string meshOpacity = "Mesh Opacity";
+        public static string opacityChange = "Opacity Change";
+
+        // Tooltips
+        public static string visibilityIconTooltip = "Visibility tool";
+        public static string characterIconTooltip = "Restore bind pose";
+        public static string spriteSheetIconTooltip = "Switch between Sprite sheet and Character mode";
+        public static string copyTooltip = "Copy";
+        public static string pasteTooltip = "Paste";
+        public static string onTooltip = "On";
+        public static string offTooltip = "Off";
+
+        // Horizontal tool bar button txt
+        public static string visibilityIconText = "Visibility";
+        public static string characterIconText = "Reset Pose";
+        public static string spriteSheetIconText = "Sprite Sheet";
+        public static string copyText = "Copy";
+        public static string pasteText = "Paste";
+
+        // Settings
+        public static string selectedOutlineColor = "Selected Outline Color";
+        public static string spriteOutlineSize = "Sprite Outline Size";
+        public static string boneOutlineSize = "Bone Outline Size";
+
+        // Sprite Library
+        public static string convertGroupToCategory = "Convert Group to Category";
+        public static string newTrailingDots = "New...";
+        public static string removeEmptyCategory = "Remove Empty Category";
+        public static string convertLayerToCategory = "Convert Layer to Category";
+        public static string clearAllCategory = "Clear All Category";
+        public static string spriteCategoryChanged = "Sprite Category Changed";
+        public static string spriteCategoryIndexChanged = "Sprite Category Index Changed";
+        public static string category = "Category";
+        public static string label = "Label";
+
+        // Other
+        public static string generatingGeometry = "Generating Geometry";
+        public static string generatingWeights = "Generating Weights";
+        public static string vertexWeight = "Vertex Weight";
+        public static string vertexWeightToolTip = "Adjust bone weights for selected vertex";
+        public static string bone = "Bone";
+        public static string depth = "Depth";
+        public static string sprite = "Sprite";
+        public static string spriteVisibility = "SpriteVisibility";
+        public static string name = "Name";
+        public static string none = "None";
+        public static string size = "Size";
+        public static string visibilityTab = "Visibility Tab";
+        public static string addBoneInfluence = "Add Bone Influence";
+        public static string removeBoneInfluence = "Remove Bone Influence";
+        public static string reorderBoneInfluence = "Reorder Bone Influence";
+        public static string noSpriteSelected = "No sprite selected";
+        public static string weightSlider = "Weight Slider";
+        public static string weightBrush = "Weight Brush";
+        public static string generateAll = "Generate All";
+        public static string generate = "Generate";
+        public static string smoothMeshError = "Generated mesh could not be smoothed. Please try using different parameters";
+        public static string copyError1 = "Unable to convert copied data to Skinning Module paste data.";
+        public static string copyError2 = "There is no copied data to paste.";
+        public static string copyError3 = "Target has a different number of Sprites ({0}) compared to copied source ({1}) for Mesh copy.";
+        public static string mode = "Mode";
+        public static string modeTooltip = "Different operation mode for weight adjustment";
+        public static string boneToolTip = "The bone that is affecting";
+    }
+}

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

@@ -0,0 +1,63 @@
+using UnityEngine;
+using UnityEngine.U2D.IK;
+
+namespace UnityEditor.U2D.IK
+{
+    /// <summary>
+    /// Custom Inspector for CCDSolver2D.
+    /// </summary>
+    [CustomEditor(typeof(CCDSolver2D))]
+    [CanEditMultipleObjects]
+    public class CCDSolver2DEditor : Solver2DEditor
+    {
+        private static class Contents
+        {
+            public static readonly GUIContent effectorLabel = new GUIContent("Effector", "The last Transform of a hierarchy constrained by the target");
+            public static readonly GUIContent targetLabel = new GUIContent("Target", "Transfrom which the effector will follow");
+            public static readonly GUIContent chainLengthLabel = new GUIContent("Chain Length", "Number of Transforms handled by the IK");
+            public static readonly GUIContent iterationsLabel = new GUIContent("Iterations", "Number of iterations the IK solver is run per frame");
+            public static readonly GUIContent toleranceLabel = new GUIContent("Tolerance", "How close the target is to the goal to be considered as successful");
+            public static readonly GUIContent velocityLabel = new GUIContent("Velocity", "How fast the chain elements rotate to the effector per iteration");
+        }
+
+        private SerializedProperty m_TargetProperty;
+        private SerializedProperty m_EffectorProperty;
+        private SerializedProperty m_TransformCountProperty;
+
+        private SerializedProperty m_IterationsProperty;
+        private SerializedProperty m_ToleranceProperty;
+        private SerializedProperty m_VelocityProperty;
+        private CCDSolver2D m_Solver;
+
+        private void OnEnable()
+        {
+            m_Solver = target as CCDSolver2D;
+            var chainProperty = serializedObject.FindProperty("m_Chain");
+            m_TargetProperty = chainProperty.FindPropertyRelative("m_TargetTransform");
+            m_EffectorProperty = chainProperty.FindPropertyRelative("m_EffectorTransform");
+            m_TransformCountProperty = chainProperty.FindPropertyRelative("m_TransformCount");
+            m_IterationsProperty = serializedObject.FindProperty("m_Iterations");
+            m_ToleranceProperty = serializedObject.FindProperty("m_Tolerance");
+            m_VelocityProperty = serializedObject.FindProperty("m_Velocity");
+        }
+
+        /// <summary>
+        /// Custom Inspector OnInspectorGUI override.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            IKChain2D chain = m_Solver.GetChain(0);
+
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_EffectorProperty, Contents.effectorLabel);
+            EditorGUILayout.PropertyField(m_TargetProperty, Contents.targetLabel);
+            EditorGUILayout.IntSlider(m_TransformCountProperty, 0, IKUtility.GetMaxChainCount(chain), Contents.chainLengthLabel);
+            EditorGUILayout.PropertyField(m_IterationsProperty, Contents.iterationsLabel);
+            EditorGUILayout.PropertyField(m_ToleranceProperty, Contents.toleranceLabel);
+            EditorGUILayout.PropertyField(m_VelocityProperty, Contents.velocityLabel);
+
+            DrawCommonSolverInspector();
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 089ed0d19d5c8124da97c7dc15838b97
+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/IK/Editor/Inspectors/FabrikSolver2DEditor.cs

@@ -0,0 +1,59 @@
+using UnityEngine;
+using UnityEngine.U2D.IK;
+
+namespace UnityEditor.U2D.IK
+{
+    /// <summary>
+    /// Custom Inspector for FabrikSolver2D.
+    /// </summary>
+    [CustomEditor(typeof(FabrikSolver2D))]
+    [CanEditMultipleObjects]
+    public class FabrikSolver2DEditor : Solver2DEditor
+    {
+        private static class Contents
+        {
+            public static readonly GUIContent effectorLabel = new GUIContent("Effector", "The last Transform of a hierarchy constrained by the target");
+            public static readonly GUIContent targetLabel = new GUIContent("Target", "Transfrom which the effector will follow");
+            public static readonly GUIContent chainLengthLabel = new GUIContent("Chain Length", "Number of Transforms handled by the IK");
+            public static readonly GUIContent iterationsLabel = new GUIContent("Iterations", "Number of iterations the IK solver is run per frame");
+            public static readonly GUIContent toleranceLabel = new GUIContent("Tolerance", "How close the target is to the goal to be considered as successful");
+        }
+
+        private SerializedProperty m_TargetProperty;
+        private SerializedProperty m_EffectorProperty;
+        private SerializedProperty m_TransformCountProperty;
+        private SerializedProperty m_IterationsProperty;
+        private SerializedProperty m_ToleranceProperty;
+        private FabrikSolver2D m_Solver;
+
+        private void OnEnable()
+        {
+            m_Solver = target as FabrikSolver2D;
+            var chainProperty = serializedObject.FindProperty("m_Chain");
+            m_TargetProperty = chainProperty.FindPropertyRelative("m_TargetTransform");
+            m_EffectorProperty = chainProperty.FindPropertyRelative("m_EffectorTransform");
+            m_TransformCountProperty = chainProperty.FindPropertyRelative("m_TransformCount");
+            m_IterationsProperty = serializedObject.FindProperty("m_Iterations");
+            m_ToleranceProperty = serializedObject.FindProperty("m_Tolerance");
+        }
+
+        /// <summary>
+        /// Custom Inspector OnInspectorGUI override.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            IKChain2D chain = m_Solver.GetChain(0);
+
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_EffectorProperty, Contents.effectorLabel);
+            EditorGUILayout.PropertyField(m_TargetProperty, Contents.targetLabel);
+            EditorGUILayout.IntSlider(m_TransformCountProperty, 0, IKUtility.GetMaxChainCount(chain), Contents.chainLengthLabel);
+            EditorGUILayout.PropertyField(m_IterationsProperty, Contents.iterationsLabel);
+            EditorGUILayout.PropertyField(m_ToleranceProperty, Contents.toleranceLabel);
+
+            DrawCommonSolverInspector();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1bbf7e9905b18064197948bb9710c04d
+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/IK/Editor/Inspectors/IKManager2DEditor.cs

@@ -0,0 +1,219 @@
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.U2D.IK;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Linq;
+using UnityEditor.U2D.Animation;
+
+namespace UnityEditor.U2D.IK
+{
+    /// <summary>
+    /// Custom Inspector for IKManager2D.
+    /// </summary>
+    [CustomEditor(typeof(IKManager2D))]
+    [CanEditMultipleObjects]
+    class IKManager2DEditor : Editor
+    {
+        private class Contents
+        {
+            public static readonly GUIContent findAllSolversLabel = new GUIContent("Find Solvers", "Find all applicable solvers handled by this manager");
+            public static readonly GUIContent weightLabel = new GUIContent("Weight", "Blend between Forward and Inverse Kinematics");
+            public static readonly string listHeaderLabel = "IK Solvers";
+            public static readonly string createSolverString = "Create Solver";
+            public static readonly string restoreDefaultPoseString = "Restore Default Pose";
+            public static readonly GUIContent gizmoColorTooltip = new GUIContent("","Customizes the IK Chain's Gizmo color");
+            public static int showGizmoPropertyWidth = 20;
+            public static int solverPropertyWidth = 100;
+            public static int solverColorPropertyWidth = 40;
+            public static readonly GUIContent gizmoVisibilityToolTip  = new GUIContent("",L10n.Tr("Show/Hide Gizmo"));
+            public readonly GUIStyle visibilityToggleStyle;
+            
+            public Contents()
+            {
+                visibilityToggleStyle = new GUIStyle();
+                visibilityToggleStyle.fixedWidth = EditorGUIUtility.singleLineHeight;
+                visibilityToggleStyle.onNormal.background = IconUtility.LoadIconResource("Visibility_Tool", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath);
+                visibilityToggleStyle.normal.background = IconUtility.LoadIconResource("Visibility_Hidded", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath);
+            }
+        }
+
+        static Contents k_Contents;
+        private ReorderableList m_ReorderableList;
+        private Solver2D m_SelectedSolver;
+        private Editor m_SelectedSolverEditor;
+
+        SerializedProperty m_SolversProperty;
+        SerializedProperty m_SolverEditorDataProperty;
+        SerializedProperty m_WeightProperty;
+        List<Type> m_SolverTypes;
+        IKManager2D m_Manager;
+
+        private void OnEnable()
+        {
+            m_Manager = target as IKManager2D;
+            m_SolverTypes = GetDerivedTypes<Solver2D>();
+            m_SolversProperty = serializedObject.FindProperty("m_Solvers");
+            m_SolverEditorDataProperty = serializedObject.FindProperty("m_SolverEditorData");
+            m_WeightProperty = serializedObject.FindProperty("m_Weight");
+            SetupReordeableList();
+        }
+
+        void SetupReordeableList()
+        {
+            m_ReorderableList = new ReorderableList(serializedObject, m_SolversProperty, true, true, true, true);
+            m_ReorderableList.drawHeaderCallback = (Rect rect) =>
+                {
+                    GUI.Label(rect, Contents.listHeaderLabel);
+                };
+            m_ReorderableList.elementHeightCallback = (int index) =>
+                {
+                    return EditorGUIUtility.singleLineHeight + 6;
+                };
+            m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isactive, bool isfocused) =>
+                {
+                    rect.y += 2f;
+                    rect.height = EditorGUIUtility.singleLineHeight;
+                    SerializedProperty element = m_SolversProperty.GetArrayElementAtIndex(index);
+                    SerializedProperty elementData = m_SolverEditorDataProperty.GetArrayElementAtIndex(index);
+                    var width = rect.width;
+                    rect.width = width > Contents.showGizmoPropertyWidth ? Contents.showGizmoPropertyWidth : width;
+                    var showGizmoProperty = elementData.FindPropertyRelative("showGizmo");
+                    showGizmoProperty.boolValue = GUI.Toggle(rect, showGizmoProperty.boolValue, Contents.gizmoVisibilityToolTip, k_Contents.visibilityToggleStyle);
+                    rect.x += rect.width;
+                    width -= rect.width;
+                    rect.width = width > Contents.solverPropertyWidth ? width - Contents.solverColorPropertyWidth  : Contents.solverPropertyWidth;
+                    EditorGUI.PropertyField(rect, element, GUIContent.none);
+                    rect.x += rect.width;
+                    width -= 100;
+                    rect.width = width > Contents.solverColorPropertyWidth ? Contents.solverColorPropertyWidth : width;
+                    EditorGUI.PropertyField(rect, elementData.FindPropertyRelative("color"), Contents.gizmoColorTooltip);
+                };
+            m_ReorderableList.onAddCallback = (ReorderableList list) =>
+                {
+                    var menu = new GenericMenu();
+
+                    foreach (Type type in m_SolverTypes)
+                    {
+                        Solver2DMenuAttribute attribute = Attribute.GetCustomAttribute(type, typeof(Solver2DMenuAttribute)) as Solver2DMenuAttribute;
+
+                        if (attribute != null)
+                            menu.AddItem(new GUIContent(attribute.menuPath), false, OnSelectMenu, type);
+                        else
+                            menu.AddItem(new GUIContent(type.Name), false, OnSelectMenu, type);
+                    }
+
+                    menu.ShowAsContext();
+                };
+            m_ReorderableList.onRemoveCallback = (ReorderableList list) =>
+                {
+                    Solver2D solver = m_Manager.solvers[list.index];
+                    if (solver)
+                    {
+                        Undo.RegisterCompleteObjectUndo(m_Manager, Undo.GetCurrentGroupName());
+
+                        m_Manager.RemoveSolver(solver);
+
+                        GameObject solverGO = solver.gameObject;
+
+                        if (solverGO.transform.childCount == 0)
+                            Undo.DestroyObjectImmediate(solverGO);
+                        else
+                            Undo.DestroyObjectImmediate(solver);
+
+                        EditorUtility.SetDirty(m_Manager);
+                    }
+                    else
+                    {
+                        ReorderableList.defaultBehaviours.DoRemoveButton(list);
+                    }
+                };
+        }
+
+        private void OnSelectMenu(object param)
+        {
+            Type solverType = param as Type;
+
+            GameObject solverGO = new GameObject(GameObjectUtility.GetUniqueNameForSibling(m_Manager.transform, "New " + solverType.Name));
+            solverGO.transform.SetParent(m_Manager.transform);
+            solverGO.transform.localPosition = Vector3.zero;
+            solverGO.transform.rotation = Quaternion.identity;
+            solverGO.transform.localScale = Vector3.one;
+
+            Solver2D solver = solverGO.AddComponent(solverType) as Solver2D;
+
+            Undo.RegisterCreatedObjectUndo(solverGO, Contents.createSolverString);
+            Undo.RegisterCompleteObjectUndo(m_Manager, Contents.createSolverString);
+            m_Manager.AddSolver(solver);
+            EditorUtility.SetDirty(m_Manager);
+
+            Selection.activeGameObject = solverGO;
+        }
+
+        /// <summary>
+        /// Custom Inspector OnInspectorGUI override.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            if(k_Contents == null)
+                k_Contents = new Contents();
+
+            serializedObject.Update();
+
+            EditorGUILayout.Space();
+
+            m_ReorderableList.DoLayoutList();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(m_WeightProperty, Contents.weightLabel);
+            
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+
+            DoRestoreDefaultPoseButton();
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DoRestoreDefaultPoseButton()
+        {
+            if (GUILayout.Button(Contents.restoreDefaultPoseString, GUILayout.MaxWidth(150f)))
+            {
+                foreach (var l_target in targets)
+                {
+                    var manager = l_target as IKManager2D;
+
+                    IKEditorManager.instance.Record(manager, Contents.restoreDefaultPoseString);
+
+                    foreach(var solver in manager.solvers)
+                    {
+                        for(int i = 0; i < solver.chainCount; ++i)
+                        {
+                            var chain = solver.GetChain(i);
+                            chain.RestoreDefaultPose(solver.constrainRotation);
+                            
+                            if(chain.target)
+                            {
+                                chain.target.position = chain.effector.position;
+                                chain.target.rotation = chain.effector.rotation;
+                            }
+                        }
+                    }
+
+                    IKEditorManager.instance.UpdateManagerImmediate(manager, true);
+                }
+            }
+        }
+
+        List<Type> GetDerivedTypes<T>() where T : class
+        {
+            List<Type> types = Assembly.GetAssembly(typeof(T)).GetTypes().Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(T))).ToList();
+            return types;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 774c00e683b6094459a1ed557b35694b
+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/IK/Editor/Inspectors/LimbSolver2DEditor.cs

@@ -0,0 +1,44 @@
+using UnityEngine;
+using UnityEngine.U2D.IK;
+
+namespace UnityEditor.U2D.IK
+{
+    /// <summary>
+    /// Custom Inspector for LimbSolver2D.
+    /// </summary>
+    [CustomEditor(typeof(LimbSolver2D))]
+    [CanEditMultipleObjects]
+    public class LimbSolver2DEditor : Solver2DEditor
+    {
+        private static class Contents
+        {
+            public static readonly GUIContent effectorLabel = new GUIContent("Effector", "The last Transform of a hierarchy constrained by the target");
+            public static readonly GUIContent targetLabel = new GUIContent("Target", "Transfrom which the effector will follow");
+            public static readonly GUIContent flipLabel = new GUIContent("Flip", "Select between the two possible solutions of the solver");
+        }
+
+        private SerializedProperty m_ChainProperty;
+        private SerializedProperty m_FlipProperty;
+
+        private void OnEnable()
+        {
+            m_ChainProperty = serializedObject.FindProperty("m_Chain");
+            m_FlipProperty = serializedObject.FindProperty("m_Flip");
+        }
+
+        /// <summary>
+        /// Custom Inspector OnInspectorGUI override.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_ChainProperty.FindPropertyRelative("m_EffectorTransform"), Contents.effectorLabel);
+            EditorGUILayout.PropertyField(m_ChainProperty.FindPropertyRelative("m_TargetTransform"), Contents.targetLabel);
+            EditorGUILayout.PropertyField(m_FlipProperty, Contents.flipLabel);
+
+            DrawCommonSolverInspector();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03bd69c1b56e1114794712e23f86f554
+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/IK/Editor/Inspectors/Solver2DEditor.cs

@@ -0,0 +1,164 @@
+using UnityEngine;
+using UnityEngine.U2D.IK;
+
+namespace UnityEditor.U2D.IK
+{
+    /// <summary>
+    /// Custom Inspector for Solver2D.
+    /// </summary>
+    [CustomEditor(typeof(Solver2D))]
+    [CanEditMultipleObjects]
+    public class Solver2DEditor : Editor
+    {
+        private static class Contents
+        {
+            public static readonly GUIContent constrainRotationLabel = new GUIContent("Constrain Rotation", "Set Effector's rotation to Target");
+            public static readonly GUIContent solveFromDefaultPoseLabel = new GUIContent("Solve from Default Pose", "Restore transform's rotation to default value before solving the IK");
+            public static readonly GUIContent weightLabel = new GUIContent("Weight", "Blend between Forward and Inverse Kinematics");
+            public static readonly string restoreDefaultPoseString = "Restore Default Pose";
+            public static readonly string createTargetString = "Create Target";
+        }
+
+        private SerializedProperty m_ConstrainRotationProperty;
+        private SerializedProperty m_SolveFromDefaultPoseProperty;
+        private SerializedProperty m_WeightProperty;
+        private SerializedProperty m_SolverColorProperty;
+
+        private void SetupProperties()
+        {
+            if(m_ConstrainRotationProperty == null || m_SolveFromDefaultPoseProperty == null || m_WeightProperty == null)
+            {
+                m_ConstrainRotationProperty = serializedObject.FindProperty("m_ConstrainRotation");
+                m_SolveFromDefaultPoseProperty = serializedObject.FindProperty("m_SolveFromDefaultPose");
+                m_WeightProperty = serializedObject.FindProperty("m_Weight");
+            }
+        }
+
+        /// <summary>
+        /// Custom Inspector GUI for Solver2D.
+        /// </summary>
+        protected void DrawCommonSolverInspector()
+        {
+            SetupProperties();
+
+            EditorGUILayout.PropertyField(m_ConstrainRotationProperty, Contents.constrainRotationLabel);
+            EditorGUILayout.PropertyField(m_SolveFromDefaultPoseProperty, Contents.solveFromDefaultPoseLabel);
+            EditorGUILayout.PropertyField(m_WeightProperty, Contents.weightLabel);
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+
+            EditorGUI.BeginDisabledGroup(!EnableCreateTarget());
+            DoCreateTargetButton();
+            EditorGUI.EndDisabledGroup();
+
+            EditorGUI.BeginDisabledGroup(!EnableRestoreDefaultPose());
+            DoRestoreDefaultPoseButton();
+            EditorGUI.EndDisabledGroup();
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Space();
+        }
+
+        private bool EnableRestoreDefaultPose()
+        {
+            foreach (var l_target in targets)
+            {
+                var solver = l_target as Solver2D;
+
+                if (!solver.isValid || IKEditorManager.instance.FindManager(solver) == null)
+                    continue;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool EnableCreateTarget()
+        {
+            foreach (var l_target in targets)
+            {
+                var solver = l_target as Solver2D;
+
+                if (!solver.isValid)
+                    continue;
+
+                for(int i = 0; i < solver.chainCount; ++i)
+                {
+                    var chain = solver.GetChain(i);
+
+                    if(chain.target == null)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private void DoRestoreDefaultPoseButton()
+        {
+            if (GUILayout.Button(Contents.restoreDefaultPoseString, GUILayout.MaxWidth(150f)))
+            {
+                foreach (var l_target in targets)
+                {
+                    var solver = l_target as Solver2D;
+
+                    if (!solver.isValid)
+                        continue;
+
+                    IKEditorManager.instance.Record(solver, Contents.restoreDefaultPoseString);
+
+                    for(int i = 0; i < solver.chainCount; ++i)
+                    {
+                        var chain = solver.GetChain(i);
+                        chain.RestoreDefaultPose(solver.constrainRotation);
+                        
+                        if(chain.target)
+                        {
+                            chain.target.position = chain.effector.position;
+                            chain.target.rotation = chain.effector.rotation;
+                        }
+                    }
+
+                    IKEditorManager.instance.UpdateSolverImmediate(solver, true);
+                }
+            }
+        }
+
+        private void DoCreateTargetButton()
+        {
+            if (GUILayout.Button(Contents.createTargetString, GUILayout.MaxWidth(125f)))
+            {
+                foreach (var l_target in targets)
+                {
+                    var solver = l_target as Solver2D;
+
+                    if (!solver.isValid)
+                        continue;
+
+                    for(int i = 0; i < solver.chainCount; ++i)
+                    {
+                        var chain = solver.GetChain(i);
+                        
+                        if(chain.target == null)
+                        {
+                            Undo.RegisterCompleteObjectUndo(solver, Contents.createTargetString);
+
+                            chain.target = new GameObject(GameObjectUtility.GetUniqueNameForSibling(solver.transform, solver.name + "_Target")).transform;
+                            chain.target.SetParent(solver.transform);
+                            chain.target.position = chain.effector.position;
+                            chain.target.rotation = chain.effector.rotation;
+
+                            Undo.RegisterCreatedObjectUndo(chain.target.gameObject, Contents.createTargetString);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4a4d0d0740dce7045a9925d5be120303
+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/IK/Runtime/IKUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b5fde14964733764c8c198a418b2eaaf
+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/IK/Runtime/LimbSolver2D.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace UnityEngine.U2D.IK
+{
+    /// <summary>
+    /// Component for 2D Limb IK.
+    /// </summary>
+    [MovedFrom("UnityEngine.Experimental.U2D.IK")]
+    [Solver2DMenuAttribute("Limb")]
+    public class LimbSolver2D : Solver2D
+    {
+        [SerializeField]
+        private IKChain2D m_Chain = new IKChain2D();
+
+        [SerializeField]
+        private bool m_Flip;
+        private Vector3[] m_Positions = new Vector3[3];
+        private float[] m_Lengths = new float[2];
+        private float[] m_Angles = new float[2];
+
+        /// <summary>
+        /// Get Set for flip property.
+        /// </summary>
+        public bool flip
+        {
+            get { return m_Flip; }
+            set { m_Flip = value; }
+        }
+
+        /// <summary>
+        /// Override base class DoInitialize.
+        /// </summary>
+        protected override void DoInitialize()
+        {
+            m_Chain.transformCount = m_Chain.effector == null || IKUtility.GetAncestorCount(m_Chain.effector) < 2 ? 0 : 3;
+            base.DoInitialize();
+        }
+
+        /// <summary>
+        /// Override base class GetChainCount.
+        /// </summary>
+        /// <returns>Always returns 1.</returns>
+        protected override int GetChainCount()
+        {
+            return 1;
+        }
+
+        /// <summary>
+        /// Override base class GetChain.
+        /// </summary>
+        /// <param name="index">Index to query.</param>
+        /// <returns>Returns IKChain2D for the Solver.</returns>
+        public override IKChain2D GetChain(int index)
+        {
+            return m_Chain;
+        }
+
+        /// <summary>
+        /// Override base class DoPrepare.
+        /// </summary>
+        protected override void DoPrepare()
+        {
+            var lengths = m_Chain.lengths;
+            m_Positions[0] = m_Chain.transforms[0].position;
+            m_Positions[1] = m_Chain.transforms[1].position;
+            m_Positions[2] = m_Chain.transforms[2].position;
+            m_Lengths[0] = lengths[0];
+            m_Lengths[1] = lengths[1];
+        }
+
+        /// <summary>
+        /// OVerride base class DoUpdateIK.
+        /// </summary>
+        /// <param name="effectorPositions">List of effector positions.</param>
+        protected override void DoUpdateIK(List<Vector3> effectorPositions)
+        {
+            Vector3 effectorPosition = effectorPositions[0];
+            Vector2 effectorLocalPosition2D = m_Chain.transforms[0].InverseTransformPoint(effectorPosition);
+            effectorPosition = m_Chain.transforms[0].TransformPoint(effectorLocalPosition2D);
+
+            if (effectorLocalPosition2D.sqrMagnitude > 0f && Limb.Solve(effectorPosition, m_Lengths, m_Positions, ref m_Angles))
+            {
+                float flipSign = flip ? -1f : 1f;
+                m_Chain.transforms[0].localRotation *= Quaternion.FromToRotation(Vector3.right, effectorLocalPosition2D) * Quaternion.FromToRotation(m_Chain.transforms[1].localPosition, Vector3.right);
+                m_Chain.transforms[0].localRotation *= Quaternion.AngleAxis(flipSign * m_Angles[0], Vector3.forward);
+                m_Chain.transforms[1].localRotation *= Quaternion.FromToRotation(Vector3.right, m_Chain.transforms[1].InverseTransformPoint(effectorPosition)) * Quaternion.FromToRotation(m_Chain.transforms[2].localPosition, Vector3.right);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 30ae93fb156fc6d4c828c64571fc3edd
+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/IK/Runtime/Solver2D.cs

@@ -0,0 +1,297 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace UnityEngine.U2D.IK
+{
+    /// <summary>
+    /// Abstract class for implementing a 2D IK Solver.
+    /// </summary>
+    [MovedFrom("UnityEngine.Experimental.U2D.IK")]
+    public abstract class Solver2D : MonoBehaviour
+    {
+        [SerializeField]
+        private bool m_ConstrainRotation = true;
+        [FormerlySerializedAs("m_RestoreDefaultPose")]
+        [SerializeField]
+        private bool m_SolveFromDefaultPose = true;
+        [SerializeField][Range(0f, 1f)]
+        private float m_Weight = 1f;
+
+        private Plane m_Plane;
+        private List<Vector3> m_TargetPositions = new List<Vector3>();
+
+        /// <summary>
+        /// Returns the number of IKChain2D in the solver.
+        /// </summary>
+        public int chainCount
+        {
+            get { return GetChainCount(); }
+        }
+
+        /// <summary>
+        /// Get Set for rotation constrain property.
+        /// </summary>
+        public bool constrainRotation
+        {
+            get { return m_ConstrainRotation; }
+            set { m_ConstrainRotation = value; }
+        }
+
+        /// <summary>
+        /// Get Set for restoring default pose.
+        /// </summary>
+        public bool solveFromDefaultPose
+        {
+            get { return m_SolveFromDefaultPose; }
+            set { m_SolveFromDefaultPose = value; }
+        }
+
+        /// <summary>
+        /// Returns true if the Solver2D is in a valid state.
+        /// </summary>
+        public bool isValid
+        {
+            get { return Validate(); }
+        }
+
+        /// <summary>
+        /// Returns true if all chains in the Solver has a target.
+        /// </summary>
+        public bool allChainsHaveTargets
+        {
+            get { return HasTargets(); }
+        }
+
+        /// <summary>
+        /// Get and Set Solver weights.
+        /// </summary>
+        public float weight
+        {
+            get { return m_Weight; }
+            set { m_Weight = Mathf.Clamp01(value); }
+        }
+
+        private void OnEnable() {}
+
+        /// <summary>
+        /// Validate and initialize the Solver.
+        /// </summary>
+        protected virtual void OnValidate()
+        {
+            m_Weight = Mathf.Clamp01(m_Weight);
+
+            if (!isValid)
+                Initialize();
+        }
+
+        private bool Validate()
+        {
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                if (!chain.isValid)
+                    return false;
+            }
+            return DoValidate();
+        }
+
+        private bool HasTargets()
+        {
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                if (chain.target == null)
+                    return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Initializes the solver.
+        /// </summary>
+        public void Initialize()
+        {
+            DoInitialize();
+
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                chain.Initialize();
+            }
+        }
+
+        private void Prepare()
+        {
+            var rootTransform = GetPlaneRootTransform();
+            if (rootTransform != null)
+            {
+                m_Plane.normal = rootTransform.forward;
+                m_Plane.distance = -Vector3.Dot(m_Plane.normal, rootTransform.position);
+            }
+
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                var constrainTargetRotation = constrainRotation && chain.target != null;
+
+                if (m_SolveFromDefaultPose)
+                    chain.RestoreDefaultPose(constrainTargetRotation);
+            }
+
+            DoPrepare();
+        }
+
+        private void PrepareEffectorPositions()
+        {
+            m_TargetPositions.Clear();
+
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+
+                if (chain.target)
+                    m_TargetPositions.Add(chain.target.position);
+            }
+        }
+
+        /// <summary>
+        /// Perfom Solver IK update.
+        /// </summary>
+        /// <param name="globalWeight">Weight for position solving.</param>
+        public void UpdateIK(float globalWeight)
+        {
+            if(allChainsHaveTargets)
+            {
+                PrepareEffectorPositions();
+                UpdateIK(m_TargetPositions, globalWeight);
+            }
+        }
+
+        /// <summary>
+        /// Perform Solver IK update.
+        /// </summary>
+        /// <param name="positions">Positions of chain.</param>
+        /// <param name="globalWeight">Weight for position solving.</param>
+        public void UpdateIK(List<Vector3> positions, float globalWeight)
+        {
+            if(positions.Count != chainCount)
+                return;
+                 
+            float finalWeight = globalWeight * weight;
+            if (finalWeight == 0f)
+                return;
+
+            if (!isValid)
+                return;
+
+            Prepare();
+
+            if (finalWeight < 1f)
+                StoreLocalRotations();
+
+            DoUpdateIK(positions);
+
+            if (constrainRotation)
+            {
+                for (int i = 0; i < GetChainCount(); ++i)
+                {
+                    var chain = GetChain(i);
+
+                    if (chain.target)
+                        chain.effector.rotation = chain.target.rotation;
+                }
+            }
+
+            if (finalWeight < 1f)
+                BlendFkToIk(finalWeight);
+        }
+
+        private void StoreLocalRotations()
+        {
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                chain.StoreLocalRotations();
+            }
+        }
+
+        private void BlendFkToIk(float finalWeight)
+        {
+            for (int i = 0; i < GetChainCount(); ++i)
+            {
+                var chain = GetChain(i);
+                var constrainTargetRotation = constrainRotation && chain.target != null;
+                chain.BlendFkToIk(finalWeight, constrainTargetRotation);
+            }
+        }
+
+        /// <summary>
+        /// Override to return the IKChain2D at the given index.
+        /// </summary>
+        /// <param name="index">Index for IKChain2D.</param>
+        /// <returns></returns>
+        public abstract IKChain2D GetChain(int index);
+        
+        /// <summary>
+        /// OVerride to return the number of chains in the Solver
+        /// </summary>
+        /// <returns>Integer represents IKChain2D count.</returns>
+        protected abstract int GetChainCount();
+        
+        /// <summary>
+        /// Override to perform Solver IK update
+        /// </summary>
+        /// <param name="effectorPositions">Position of the effectors.</param>
+        protected abstract void DoUpdateIK(List<Vector3> effectorPositions);
+
+        /// <summary>
+        /// Override to perform custom validation.
+        /// </summary>
+        /// <returns>Returns true if the Solver is in a valid state. False otherwise.</returns>
+        protected virtual bool DoValidate() { return true; }
+        
+        /// <summary>
+        /// Override to perform initialize the solver
+        /// </summary>
+        protected virtual void DoInitialize() {}
+        
+        /// <summary>
+        /// Override to prepare the solver for update
+        /// </summary>
+        protected virtual void DoPrepare() {}
+        
+        /// <summary>
+        /// Override to return the root Unity Transform of the Solver. The default implementation returns the root
+        /// transform of the first chain.
+        /// </summary>
+        /// <returns>Unity Transform that represents the root.</returns>
+        protected virtual Transform GetPlaneRootTransform()
+        {
+            if (chainCount > 0)
+                return GetChain(0).rootTransform;
+            return null;
+        }
+
+        /// <summary>
+        /// Convert a world position coordinate to the solver's plane space
+        /// </summary>
+        /// <param name="worldPosition">Vector3 representing world position</param>
+        /// <returns>Converted position in solver's plane</returns>
+        protected Vector3 GetPointOnSolverPlane(Vector3 worldPosition)
+        {
+            return GetPlaneRootTransform().InverseTransformPoint(m_Plane.ClosestPointOnPlane(worldPosition));
+        }
+
+        /// <summary>
+        /// Convert a position from solver's plane to world coordinate
+        /// </summary>
+        /// <param name="planePoint">Vector3 representing a position in the Solver's plane.</param>
+        /// <returns>Converted position to world coordinate.</returns>
+        protected Vector3 GetWorldPositionFromSolverPlanePoint(Vector2 planePoint)
+        {
+            return GetPlaneRootTransform().TransformPoint(planePoint);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd469cc9c7a046649b08db54fa8e1cca
+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/IK/Runtime/Solver2DMenuAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace UnityEngine.U2D.IK
+{
+    /// <summary>
+    /// Attribute to add a menu item in IKManager2D to create the Solver.
+    /// </summary>
+    [MovedFrom("UnityEngine.Experimental.U2D.IK")]
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class Solver2DMenuAttribute : Attribute
+    {
+        string m_MenuPath;
+
+        /// <summary>
+        /// Menu path.
+        /// </summary>
+        public string menuPath
+        {
+            get { return m_MenuPath; }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="_menuPath">Menu item path.</param>
+        public Solver2DMenuAttribute(string _menuPath)
+        {
+            m_MenuPath = _menuPath;
+        }
+    }
+}