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/SkinningModule/Icons/Dark/d_Create_Edge.png.meta

@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 7a5bb676bcccfea429f2138b6fbd005e
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 1c82d3f0af949d7438bfd489d34048f0
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 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/Assets/SkinningModule/Icons/Light/Bone_Influence@4x.png.meta

@@ -0,0 +1,140 @@
+fileFormatVersion: 2
+guid: c7aa62ae78ffca0498c89e5f45f94c0e
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: cb273ff7193bbe04d8d2a812a6533329
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 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/Assets/SkinningModule/PastePanelStyle.uss.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 2362443a3fd04784d9c18412e771c7fa
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

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

@@ -0,0 +1,100 @@
+
+Shader "Hidden/SkinningModule-GUITextureClip"
+{
+    Properties {
+        _MainTex ("Texture", Any) = "white" {}
+        _Opacity ("Opacity", Float) = 1
+        _VertexColorBlend ("VertexColorBlend", Float) = 0
+        _Color ("Tint", Color) = (1,1,1,1)
+    }
+
+    CGINCLUDE
+    #pragma vertex vert
+    #pragma fragment frag
+    #pragma target 2.0
+
+    #include "UnityCG.cginc"
+
+    struct appdata_t {
+        float4 vertex : POSITION;
+        fixed4 color : COLOR;
+        float2 texcoord : TEXCOORD0;
+        UNITY_VERTEX_INPUT_INSTANCE_ID
+    };
+
+    struct v2f {
+        float4 vertex : SV_POSITION;
+        fixed4 color : COLOR;
+        float2 texcoord : TEXCOORD0;
+        float2 clipUV : TEXCOORD1;
+        UNITY_VERTEX_OUTPUT_STEREO
+    };
+
+    sampler2D _MainTex;
+    sampler2D _GUIClipTexture;
+
+    uniform float4 _MainTex_ST;
+    fixed4 _Color;
+    uniform fixed _Opacity;
+    uniform fixed _VertexColorBlend;
+    uniform float4x4 unity_GUIClipTextureMatrix;
+    uniform bool _AdjustLinearForGamma;
+
+    v2f vert (appdata_t v)
+    {
+        v2f o;
+        UNITY_SETUP_INSTANCE_ID(v);
+        UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+        o.vertex = UnityObjectToClipPos(v.vertex);
+        float3 eyePos = UnityObjectToViewPos(v.vertex);
+        o.clipUV = mul(unity_GUIClipTextureMatrix, float4(eyePos.xy, 0, 1.0));
+        o.color = v.color;
+        o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+        return o;
+    }
+
+    fixed4 frag (v2f i) : SV_Target
+    {
+        fixed4 col = tex2D(_MainTex, i.texcoord) * _Color;
+
+        if (_AdjustLinearForGamma)
+            col.rgb = LinearToGammaSpace(col.rgb);
+
+        col = lerp(col, i.color, _VertexColorBlend);
+        col.a *= tex2D(_GUIClipTexture, i.clipUV).a * _Opacity;
+        return col;
+    }
+    ENDCG
+
+    SubShader {
+
+        Tags { "ForceSupported" = "True" }
+
+        Lighting Off
+        Blend SrcAlpha OneMinusSrcAlpha, One One
+        Cull Off
+        ZWrite Off
+        ZTest Always
+
+        Pass {
+            CGPROGRAM
+            ENDCG
+        }
+    }
+
+    SubShader {
+
+        Tags { "ForceSupported" = "True" }
+
+        Lighting Off
+        Blend SrcAlpha OneMinusSrcAlpha
+        Cull Off
+        ZWrite Off
+        ZTest Always
+
+        Pass {
+            CGPROGRAM
+            ENDCG
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bedd19944f451ba4d83e7ed69be98d5c
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

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

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

@@ -0,0 +1,754 @@
+#if ENABLE_ANIMATION_COLLECTION
+using System;
+using Unity.Mathematics;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Jobs;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine.U2D.Common;
+using UnityEngine.Profiling;
+using Unity.Burst;
+using UnityEngine.Assertions;
+
+namespace UnityEngine.U2D.Animation
+{
+    internal struct PerSkinJobData
+    {
+        public int deformVerticesStartPos;
+        public int2 bindPosesIndex;
+        public int2 verticesIndex;
+    }
+
+    internal struct SpriteSkinData
+    {
+        public NativeCustomSlice<Vector3> vertices;
+        public NativeCustomSlice<BoneWeight> boneWeights;
+        public NativeCustomSlice<Matrix4x4> bindPoses;
+        public NativeCustomSlice<Vector4> tangents;
+        public bool hasTangents;
+        public int spriteVertexStreamSize;
+        public int spriteVertexCount;
+        public int tangentVertexOffset;
+        public int deformVerticesStartPos;
+        public int transformId;
+        public NativeCustomSlice<int> boneTransformId;
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif 
+    internal struct PrepareDeformJob :IJob
+    {
+        [ReadOnly]
+        public NativeArray<PerSkinJobData> perSkinJobData;
+        [ReadOnly]
+        public int batchDataSize;
+        [WriteOnly]
+        public NativeArray<int2> boneLookupData;
+        [WriteOnly]
+        public NativeArray<int2> vertexLookupData;
+
+        public void Execute()
+        {
+            for (int i = 0; i < batchDataSize; ++i)
+            {
+                var jobData = perSkinJobData[i];
+                for (int k = 0, j = jobData.bindPosesIndex.x; j < jobData.bindPosesIndex.y; ++j, ++k)
+                {
+                    boneLookupData[j] = new int2(i, k);
+                }
+                for (int k = 0, j = jobData.verticesIndex.x; j < jobData.verticesIndex.y; ++j, ++k)
+                {
+                    vertexLookupData[j] = new int2(i, k);
+                }
+            }
+        }
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif 
+    internal struct BoneDeformBatchedJob : IJobParallelFor
+    {
+        [ReadOnly]
+        public NativeArray<float4x4> boneTransform;
+        [ReadOnly]
+        public NativeArray<float4x4> rootTransform;
+        [ReadOnly]
+        public NativeArray<int2> boneLookupData;
+        [ReadOnly]
+        public NativeArray<SpriteSkinData> spriteSkinData;
+        [ReadOnly]
+        public NativeHashMap<int, TransformAccessJob.TransformData> rootTransformIndex;
+        [ReadOnly]
+        public NativeHashMap<int, TransformAccessJob.TransformData> boneTransformIndex;
+        [WriteOnly]
+        public NativeArray<float4x4> finalBoneTransforms;
+
+        public void Execute(int i)
+        {
+            int x = boneLookupData[i].x;
+            int y = boneLookupData[i].y;
+            var ssd = spriteSkinData[x];
+            var v = ssd.boneTransformId[y];
+            var index = boneTransformIndex[v].transformIndex;
+            if (index < 0)
+                return;
+            var aa = boneTransform[index];
+            var bb = ssd.bindPoses[y];
+            var cc = rootTransformIndex[ssd.transformId].transformIndex;
+            finalBoneTransforms[i] = math.mul(rootTransform[cc], math.mul(aa, bb));
+        }
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif 
+
+    internal struct SkinDeformBatchedJob : IJobParallelFor
+    {
+        public NativeSlice<byte> vertices;
+
+        [ReadOnly]
+        public NativeArray<float4x4> finalBoneTransforms;
+        [ReadOnly]
+        public NativeArray<PerSkinJobData> perSkinJobData;
+        [ReadOnly]
+        public NativeArray<SpriteSkinData> spriteSkinData;
+        [ReadOnly]
+        public NativeArray<int2> vertexLookupData;
+
+        public unsafe void Execute(int i)
+        {
+            int j = vertexLookupData[i].x;
+            int k = vertexLookupData[i].y;
+
+            PerSkinJobData perSkinData = perSkinJobData[j];
+            var spriteSkin = spriteSkinData[j];
+            float3 srcVertex = spriteSkin.vertices[k];
+            float4 tangents = spriteSkin.tangents[k];
+            var influence = spriteSkin.boneWeights[k];
+
+            int bone0 = influence.boneIndex0 + perSkinData.bindPosesIndex.x;
+            int bone1 = influence.boneIndex1 + perSkinData.bindPosesIndex.x;
+            int bone2 = influence.boneIndex2 + perSkinData.bindPosesIndex.x;
+            int bone3 = influence.boneIndex3 + perSkinData.bindPosesIndex.x;
+
+            byte* deformedPosOffset = (byte*)vertices.GetUnsafePtr();
+            byte* deformedPosStart = deformedPosOffset + spriteSkin.deformVerticesStartPos;
+            NativeSlice<float3> deformableVerticesFloat3 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice<float3>(deformedPosStart, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount);
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableVerticesFloat3, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices));
+#endif
+            if (spriteSkin.hasTangents)
+            {
+                byte* deformedTanOffset = deformedPosStart + spriteSkin.tangentVertexOffset;
+                var deformableTangentsFloat4 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice<float4>(deformedTanOffset, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount);
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableTangentsFloat4, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices));
+#endif
+                var tangent = new float4(tangents.xyz, 0.0f);
+                tangent =
+                    math.mul(finalBoneTransforms[bone0], tangent) * influence.weight0 +
+                    math.mul(finalBoneTransforms[bone1], tangent) * influence.weight1 +
+                    math.mul(finalBoneTransforms[bone2], tangent) * influence.weight2 +
+                    math.mul(finalBoneTransforms[bone3], tangent) * influence.weight3;
+                deformableTangentsFloat4[k] = new float4(math.normalize(tangent.xyz), tangents.w);
+            }
+            
+            deformableVerticesFloat3[k] =
+                math.transform(finalBoneTransforms[bone0], srcVertex) * influence.weight0 +
+                math.transform(finalBoneTransforms[bone1], srcVertex) * influence.weight1 +
+                math.transform(finalBoneTransforms[bone2], srcVertex) * influence.weight2 +
+                math.transform(finalBoneTransforms[bone3], srcVertex) * influence.weight3;
+        }
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif 
+    internal struct CalculateSpriteSkinAABBJob : IJobParallelFor
+    {
+        public NativeSlice<byte> vertices;
+        [ReadOnly] 
+        public NativeArray<bool> isSpriteSkinValidForDeformArray;
+        [ReadOnly]
+        public NativeArray<SpriteSkinData> spriteSkinData;
+
+        [WriteOnly]
+        public NativeArray<Bounds> bounds;
+
+        public unsafe void Execute(int i)
+        {
+            if (!isSpriteSkinValidForDeformArray[i])
+                return;
+
+            var spriteSkin = spriteSkinData[i];
+            byte* deformedPosOffset = (byte*)vertices.GetUnsafePtr();
+            NativeSlice<float3> deformableVerticesFloat3 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice<float3>(deformedPosOffset + spriteSkin.deformVerticesStartPos, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount);
+
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableVerticesFloat3, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices));
+#endif
+
+            bounds[i] = SpriteSkinUtility.CalculateSpriteSkinBounds(deformableVerticesFloat3);
+        }
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif
+    internal struct FillPerSkinJobSingleThread : IJob
+    {
+        public PerSkinJobData combinedSkinBatch;
+
+        [ReadOnly]
+        public NativeArray<bool> isSpriteSkinValidForDeformArray;
+
+        public NativeArray<SpriteSkinData> spriteSkinDataArray;
+        public NativeArray<PerSkinJobData> perSkinJobDataArray;
+
+        public NativeArray<PerSkinJobData> combinedSkinBatchArray;
+
+        public void Execute()
+        {
+            var startIndex = 0;
+            var endIndex = spriteSkinDataArray.Length;
+            for (int index = startIndex; index < endIndex; ++index)
+            {
+                var spriteSkinData = spriteSkinDataArray[index];
+                spriteSkinData.deformVerticesStartPos = -1;
+                var vertexBufferSize = 0;
+                var vertexCount = 0;
+                var bindPoseCount = 0;
+                if (isSpriteSkinValidForDeformArray[index])
+                {
+                    spriteSkinData.deformVerticesStartPos = combinedSkinBatch.deformVerticesStartPos;
+                    vertexBufferSize = spriteSkinData.spriteVertexCount * spriteSkinData.spriteVertexStreamSize;
+                    vertexCount = spriteSkinData.spriteVertexCount;
+                    bindPoseCount = spriteSkinData.bindPoses.Length;
+                }
+                combinedSkinBatch.verticesIndex.x = combinedSkinBatch.verticesIndex.y;
+                combinedSkinBatch.verticesIndex.y = combinedSkinBatch.verticesIndex.x + vertexCount;
+                combinedSkinBatch.bindPosesIndex.x = combinedSkinBatch.bindPosesIndex.y;
+                combinedSkinBatch.bindPosesIndex.y = combinedSkinBatch.bindPosesIndex.x + bindPoseCount;
+                spriteSkinDataArray[index] = spriteSkinData;
+                perSkinJobDataArray[index] = combinedSkinBatch;
+                combinedSkinBatch.deformVerticesStartPos += vertexBufferSize;
+            }
+            combinedSkinBatchArray[0] = combinedSkinBatch;
+        }
+    }
+
+#if ENABLE_ANIMATION_BURST
+    [BurstCompile]
+#endif 
+    internal struct CopySpriteRendererBuffersJob : IJobParallelFor
+    {
+        [ReadOnly]
+        public NativeArray<bool> isSpriteSkinValidForDeformArray;
+        [ReadOnly]
+        public NativeArray<SpriteSkinData> spriteSkinData;
+        [ReadOnly, NativeDisableUnsafePtrRestriction]
+        public IntPtr ptrVertices;
+
+        [WriteOnly]
+        public NativeArray<IntPtr> buffers;
+        [WriteOnly]
+        public NativeArray<int> bufferSizes;
+        
+        public void Execute(int i)
+        {
+            var skinData = spriteSkinData[i];
+            IntPtr startVertices = default(IntPtr);
+            var vertexBufferLength = 0;
+            if (isSpriteSkinValidForDeformArray[i])
+            {
+                startVertices = ptrVertices + skinData.deformVerticesStartPos;
+                vertexBufferLength = skinData.spriteVertexCount * skinData.spriteVertexStreamSize;
+            }
+            buffers[i] = startVertices;
+            bufferSizes[i] = vertexBufferLength;
+        }
+    }    
+
+    internal class SpriteSkinComposite : ScriptableObject
+    {
+        static SpriteSkinComposite m_Instance;
+
+        public static SpriteSkinComposite instance
+        {
+            get
+            {
+                if (m_Instance == null)
+                {
+                    var composite = Resources.FindObjectsOfTypeAll<SpriteSkinComposite>();
+                    if (composite.Length > 0)
+                        m_Instance = composite[0];
+                    else
+                        m_Instance = ScriptableObject.CreateInstance<SpriteSkinComposite>();
+                    m_Instance.hideFlags = HideFlags.HideAndDontSave;
+                    m_Instance.Init();
+                }
+                return m_Instance;
+            }
+        }
+
+        List<SpriteSkin> m_SpriteSkins = new List<SpriteSkin>();
+        List<SpriteSkin> m_SpriteSkinLateUpdate = new List<SpriteSkin>();
+        SpriteRenderer[] m_SpriteRenderers = new SpriteRenderer[0];
+
+        DeformVerticesBuffer m_DeformedVerticesBuffer;
+        NativeArray<float4x4> m_FinalBoneTransforms;
+
+        NativeArray<bool> m_IsSpriteSkinActiveForDeform;
+        NativeArray<SpriteSkinData> m_SpriteSkinData;
+        NativeArray<PerSkinJobData> m_PerSkinJobData;
+        NativeArray<Bounds> m_BoundsData;
+        NativeArray<IntPtr> m_Buffers;
+        NativeArray<int> m_BufferSizes;
+
+        NativeArray<int2> m_BoneLookupData;
+        NativeArray<int2> m_VertexLookupData;
+        NativeArray<PerSkinJobData> m_SkinBatchArray;
+        TransformAccessJob m_LocalToWorldTransformAccessJob;
+        TransformAccessJob m_WorldToLocalTransformAccessJob;
+        JobHandle m_BoundJobHandle;
+        JobHandle m_DeformJobHandle;
+        JobHandle m_CopyJobHandle;
+
+        [SerializeField]
+        GameObject m_Helper;
+
+        internal GameObject helperGameObject
+        {
+            get => m_Helper;
+        }
+
+        internal void RemoveTransformById(int transformId)
+        {
+            m_LocalToWorldTransformAccessJob.RemoveTransformById(transformId);
+        }
+
+        internal void AddSpriteSkinBoneTransform(SpriteSkin spriteSkin)
+        {
+            if (spriteSkin == null)
+                return;
+            if (spriteSkin.boneTransforms != null)
+            {
+                foreach (var t in spriteSkin.boneTransforms)
+                {
+                    if(t != null)
+                        m_LocalToWorldTransformAccessJob.AddTransform(t);
+                }
+            }
+        }
+
+        internal void AddSpriteSkinRootBoneTransform(SpriteSkin spriteSkin)
+        {
+            if (spriteSkin == null || spriteSkin.rootBone == null)
+                return;
+            m_LocalToWorldTransformAccessJob.AddTransform(spriteSkin.rootBone);
+        }
+
+        internal void AddSpriteSkin(SpriteSkin spriteSkin)
+        {
+            if (spriteSkin == null)
+                return;
+
+            bool added = m_SpriteSkins.Contains(spriteSkin);
+            Debug.Assert(!added, string.Format("SpriteSkin {0} is already added", spriteSkin.gameObject.name));
+            if (!added)
+            {
+                m_SpriteSkins.Add(spriteSkin);
+                var count = m_SpriteSkins.Count;
+                Array.Resize(ref m_SpriteRenderers, count);
+                m_SpriteRenderers[count - 1] = spriteSkin.spriteRenderer;
+                m_WorldToLocalTransformAccessJob.AddTransform(spriteSkin.transform);
+                if (m_IsSpriteSkinActiveForDeform.IsCreated)
+                {
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_IsSpriteSkinActiveForDeform, count);
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_PerSkinJobData, count);
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_SpriteSkinData, count);
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_BoundsData, count);
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_Buffers, count);
+                    NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_BufferSizes, count);
+                    CopyToSpriteSkinData(count - 1);
+                }
+            }
+        }
+
+        internal void CopyToSpriteSkinData(SpriteSkin spriteSkin)
+        {
+            if (spriteSkin == null)
+                return;
+            int index = m_SpriteSkins.IndexOf(spriteSkin);
+            if (index < 0)
+                return;
+            CopyToSpriteSkinData(index);
+        }
+
+        private void CopyToSpriteSkinData(int index)
+        {
+            if (index < 0 || index >= m_SpriteSkins.Count || !m_SpriteSkinData.IsCreated)
+                return;
+
+            SpriteSkinData spriteSkinData = default(SpriteSkinData);
+            var spriteSkin = m_SpriteSkins[index];
+            spriteSkin.CopyToSpriteSkinData(ref spriteSkinData, index);
+            m_SpriteSkinData[index] = spriteSkinData;
+            m_SpriteRenderers[index] = spriteSkin.spriteRenderer;
+        }
+
+        internal void RemoveSpriteSkin(SpriteSkin spriteSkin)
+        {
+            int index = m_SpriteSkins.IndexOf(spriteSkin);
+            if (index < 0)
+                return;
+
+            // Check if it is not the last SpriteSkin
+            if (index < m_SpriteSkins.Count - 1)
+            {
+                m_SpriteSkins.RemoveAtSwapBack(index);
+                CopyToSpriteSkinData(index);
+            }
+            else
+            {
+                m_SpriteSkins.RemoveAt(index);
+            }
+
+            var count = m_SpriteSkins.Count;
+            Array.Resize(ref m_SpriteRenderers, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_IsSpriteSkinActiveForDeform, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_PerSkinJobData, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_SpriteSkinData, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_BoundsData, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_Buffers, count);
+            NativeArrayHelpers.ResizeAndCopyIfNeeded(ref m_BufferSizes, count);
+
+            m_WorldToLocalTransformAccessJob.RemoveTransform(spriteSkin.transform);
+        }
+
+        internal void AddSpriteSkinForLateUpdate(SpriteSkin spriteSkin)
+        {
+            if (spriteSkin == null)
+                return;
+
+            bool added = m_SpriteSkinLateUpdate.Contains(spriteSkin);
+            Debug.Assert( !added, string.Format("SpriteSkin {0} is already added for LateUpdate", spriteSkin.gameObject.name));
+            if (!added)
+            {
+                m_SpriteSkinLateUpdate.Add(spriteSkin);
+            }
+        }
+
+        internal void RemoveSpriteSkinForLateUpdate(SpriteSkin spriteSkin)
+        {
+            m_SpriteSkinLateUpdate.Remove(spriteSkin);
+        }
+
+        void Init()
+        {
+            if(m_LocalToWorldTransformAccessJob == null)
+                m_LocalToWorldTransformAccessJob = new TransformAccessJob();
+            if(m_WorldToLocalTransformAccessJob == null)
+                m_WorldToLocalTransformAccessJob = new TransformAccessJob();
+        }
+
+        internal void ResetComposite()
+        {
+            foreach (var spriteSkin in m_SpriteSkins)
+                spriteSkin.batchSkinning = false;
+            m_SpriteSkins.Clear();
+            m_LocalToWorldTransformAccessJob.Destroy();
+            m_WorldToLocalTransformAccessJob.Destroy();
+            m_LocalToWorldTransformAccessJob = new TransformAccessJob();
+            m_WorldToLocalTransformAccessJob = new TransformAccessJob();
+        }
+
+        public void OnEnable()
+        {
+            m_Instance = this;
+            if (m_Helper == null)
+            {
+                m_Helper = new GameObject("SpriteSkinManager");
+                m_Helper.hideFlags = HideFlags.HideAndDontSave;
+                m_Helper.AddComponent<SpriteSkinManager.SpriteSkinManagerInternal>();
+#if !UNITY_EDITOR
+                GameObject.DontDestroyOnLoad(m_Helper);
+#endif
+            }
+
+            m_DeformedVerticesBuffer = new DeformVerticesBuffer(DeformVerticesBuffer.k_DefaultBufferSize);
+            m_FinalBoneTransforms = new NativeArray<float4x4>(1, Allocator.Persistent);
+            m_BoneLookupData = new NativeArray<int2>(1, Allocator.Persistent);
+            m_VertexLookupData = new NativeArray<int2>(1, Allocator.Persistent);
+            m_SkinBatchArray = new NativeArray<PerSkinJobData>(1, Allocator.Persistent);
+
+            Init();
+
+            // Initialise all existing SpriteSkins as execution order is indeterminate
+            int count = m_SpriteSkins.Count; 
+            if (count > 0)
+            {
+                m_IsSpriteSkinActiveForDeform = new NativeArray<bool>(count, Allocator.Persistent);
+                m_PerSkinJobData = new NativeArray<PerSkinJobData>(count, Allocator.Persistent);
+                m_SpriteSkinData = new NativeArray<SpriteSkinData>(count, Allocator.Persistent);
+                m_BoundsData = new NativeArray<Bounds>(count, Allocator.Persistent);
+                m_Buffers = new NativeArray<IntPtr>(count, Allocator.Persistent);
+                m_BufferSizes = new NativeArray<int>(count, Allocator.Persistent);
+                for (int i = 0; i < count; ++i)
+                {
+                    var spriteSkin = m_SpriteSkins[i];
+                    spriteSkin.batchSkinning = true;
+                    CopyToSpriteSkinData(i);
+                }
+            }
+            else
+            {
+                m_IsSpriteSkinActiveForDeform = new NativeArray<bool>(1, Allocator.Persistent);
+                m_PerSkinJobData = new NativeArray<PerSkinJobData>(1, Allocator.Persistent);
+                m_SpriteSkinData = new NativeArray<SpriteSkinData>(1, Allocator.Persistent);
+                m_BoundsData = new NativeArray<Bounds>(1, Allocator.Persistent);
+                m_Buffers = new NativeArray<IntPtr>(1, Allocator.Persistent);
+                m_BufferSizes = new NativeArray<int>(1, Allocator.Persistent);
+            }
+        }
+
+        private void OnDisable()
+        {
+            m_DeformJobHandle.Complete();
+            m_BoundJobHandle.Complete();
+            m_CopyJobHandle.Complete();
+            foreach (var spriteSkin in m_SpriteSkins)
+                spriteSkin.batchSkinning = false;
+            m_SpriteSkins.Clear();
+            m_SpriteRenderers = new SpriteRenderer[0];
+            m_DeformedVerticesBuffer.Dispose();
+            m_IsSpriteSkinActiveForDeform.DisposeIfCreated();
+            m_PerSkinJobData.DisposeIfCreated();
+            m_SpriteSkinData.DisposeIfCreated();
+            m_Buffers.DisposeIfCreated();
+            m_BufferSizes.DisposeIfCreated();
+            m_BoneLookupData.DisposeIfCreated();
+            m_VertexLookupData.DisposeIfCreated();
+            m_SkinBatchArray.DisposeIfCreated();
+            m_FinalBoneTransforms.DisposeIfCreated();
+            m_BoundsData.DisposeIfCreated();
+            if (m_Helper != null)
+                GameObject.DestroyImmediate(m_Helper);
+            m_LocalToWorldTransformAccessJob.Destroy();
+            m_WorldToLocalTransformAccessJob.Destroy();
+        }
+
+        internal unsafe void LateUpdate()
+        {
+            foreach (var ss in m_SpriteSkinLateUpdate)
+            {
+                if(ss != null)
+                    ss.OnLateUpdate();
+            }
+
+            var count = m_SpriteSkins.Count;
+            if (count == 0)
+                return;
+
+            Profiler.BeginSample("SpriteSkinComposite.PrepareData");
+            Assert.AreEqual(m_IsSpriteSkinActiveForDeform.Length, count);
+            Assert.AreEqual(m_PerSkinJobData.Length, count);
+            Assert.AreEqual(m_SpriteSkinData.Length, count);
+            Assert.AreEqual(m_BoundsData.Length, count);
+            Assert.AreEqual(m_Buffers.Length, count);
+            Assert.AreEqual(m_BufferSizes.Length, count);
+            Assert.AreEqual(m_SpriteRenderers.Length, count);
+
+            Profiler.BeginSample("SpriteSkinComposite.ValidateSpriteSkinData");
+            for (int i = 0; i < m_SpriteSkins.Count; ++i)
+            {
+                var spriteSkin = m_SpriteSkins[i];
+                m_IsSpriteSkinActiveForDeform[i] = spriteSkin.BatchValidate();
+                if (m_IsSpriteSkinActiveForDeform[i] && spriteSkin.NeedUpdateCompositeCache())
+                {
+                    CopyToSpriteSkinData(i);
+                }
+            }
+            Profiler.EndSample();
+
+            Profiler.BeginSample("SpriteSkinComposite.TransformAccessJob");
+            var localToWorldJobHandle = m_LocalToWorldTransformAccessJob.StartLocalToWorldJob();
+            var worldToLocalJobHandle = m_WorldToLocalTransformAccessJob.StartWorldToLocalJob();
+            Profiler.EndSample();
+
+            Profiler.BeginSample("SpriteSkinComposite.GetSpriteSkinBatchData");
+            NativeArrayHelpers.ResizeIfNeeded(ref m_SkinBatchArray, 1);
+            FillPerSkinJobSingleThread fillPerSkinJobSingleThread = new FillPerSkinJobSingleThread()
+            {
+                isSpriteSkinValidForDeformArray = m_IsSpriteSkinActiveForDeform,
+                combinedSkinBatchArray = m_SkinBatchArray,
+                spriteSkinDataArray = m_SpriteSkinData,
+                perSkinJobDataArray = m_PerSkinJobData,
+            };
+            fillPerSkinJobSingleThread.Run();
+            Profiler.EndSample();
+            Profiler.EndSample();
+
+            var skinBatch = m_SkinBatchArray[0];
+            int batchCount = m_SpriteSkinData.Length;
+            int vertexBufferSize = skinBatch.deformVerticesStartPos;
+            if (vertexBufferSize <= 0)
+            {
+                localToWorldJobHandle.Complete();
+                worldToLocalJobHandle.Complete();
+                return;
+            }
+
+            Profiler.BeginSample("SpriteSkinComposite.ResizeBuffers");
+            var deformVertices = m_DeformedVerticesBuffer.GetBuffer(vertexBufferSize);
+            NativeArrayHelpers.ResizeIfNeeded(ref m_FinalBoneTransforms, skinBatch.bindPosesIndex.y);
+            NativeArrayHelpers.ResizeIfNeeded(ref m_BoneLookupData, skinBatch.bindPosesIndex.y);
+            NativeArrayHelpers.ResizeIfNeeded(ref m_VertexLookupData, skinBatch.verticesIndex.y);
+            Profiler.EndSample();
+
+            Profiler.BeginSample("SpriteSkinComposite.Prepare");
+            PrepareDeformJob prepareJob = new PrepareDeformJob
+            {
+                batchDataSize = batchCount,
+                perSkinJobData = m_PerSkinJobData,
+                boneLookupData = m_BoneLookupData,
+                vertexLookupData = m_VertexLookupData
+            };
+            var jobHandle = prepareJob.Schedule();
+            Profiler.EndSample();
+
+            Profiler.BeginSample("SpriteSkinComposite.ScheduleJobs");
+            BoneDeformBatchedJob boneJobBatched = new BoneDeformBatchedJob()
+            {
+                boneTransform = m_LocalToWorldTransformAccessJob.transformMatrix,
+                rootTransform = m_WorldToLocalTransformAccessJob.transformMatrix,
+                spriteSkinData = m_SpriteSkinData,
+                boneLookupData = m_BoneLookupData,
+                finalBoneTransforms = m_FinalBoneTransforms,
+                rootTransformIndex = m_WorldToLocalTransformAccessJob.transformData,
+                boneTransformIndex = m_LocalToWorldTransformAccessJob.transformData
+            };
+            jobHandle = JobHandle.CombineDependencies(localToWorldJobHandle, worldToLocalJobHandle, jobHandle);
+            jobHandle = boneJobBatched.Schedule(skinBatch.bindPosesIndex.y, 8, jobHandle);
+
+            SkinDeformBatchedJob skinJobBatched = new SkinDeformBatchedJob()
+            {
+                vertices = deformVertices,
+                vertexLookupData = m_VertexLookupData,
+                spriteSkinData = m_SpriteSkinData,
+                perSkinJobData = m_PerSkinJobData,
+                finalBoneTransforms = m_FinalBoneTransforms,
+            };
+            m_DeformJobHandle = skinJobBatched.Schedule(skinBatch.verticesIndex.y, 16, jobHandle);
+
+            CopySpriteRendererBuffersJob copySpriteRendererBuffersJob = new CopySpriteRendererBuffersJob()
+            {
+                isSpriteSkinValidForDeformArray = m_IsSpriteSkinActiveForDeform,
+                spriteSkinData = m_SpriteSkinData,
+                ptrVertices = (IntPtr) NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(deformVertices),
+                buffers = m_Buffers,
+                bufferSizes = m_BufferSizes,
+            };
+            m_CopyJobHandle = copySpriteRendererBuffersJob.Schedule(batchCount, 16, jobHandle);
+
+            CalculateSpriteSkinAABBJob updateBoundJob = new CalculateSpriteSkinAABBJob
+            {
+                vertices = deformVertices,
+                isSpriteSkinValidForDeformArray = m_IsSpriteSkinActiveForDeform,
+                spriteSkinData = m_SpriteSkinData,
+                bounds = m_BoundsData,
+            };
+            m_BoundJobHandle = updateBoundJob.Schedule(batchCount, 4, m_DeformJobHandle);
+            Profiler.EndSample();
+
+            JobHandle.ScheduleBatchedJobs();
+            jobHandle = JobHandle.CombineDependencies(m_BoundJobHandle, m_CopyJobHandle);
+            jobHandle.Complete();
+
+            Profiler.BeginSample("SpriteSkinComposite.SetBatchDeformableBufferAndLocalAABB");
+            InternalEngineBridge.SetBatchDeformableBufferAndLocalAABBArray(m_SpriteRenderers, m_Buffers, m_BufferSizes, m_BoundsData);
+            Profiler.EndSample();
+        }
+
+        internal bool HasDeformableBufferForSprite(int dataIndex)
+        {
+            if (dataIndex < 0 && m_IsSpriteSkinActiveForDeform.Length >= dataIndex)
+                throw new InvalidOperationException("Invalid index for deformable buffer");
+            return m_IsSpriteSkinActiveForDeform[dataIndex];
+        }
+
+        internal unsafe NativeArray<byte> GetDeformableBufferForSprite(int dataIndex)
+        {
+            if (dataIndex < 0 && m_SpriteSkinData.Length >= dataIndex)
+                throw new InvalidOperationException("Invalid index for deformable buffer");
+            
+            if (!m_DeformJobHandle.IsCompleted)
+                m_DeformJobHandle.Complete();
+
+            var skinData = m_SpriteSkinData[dataIndex];
+            if (skinData.deformVerticesStartPos < 0)
+                throw new InvalidOperationException("There are no currently deformed vertices.");
+
+            var vertexBufferLength = skinData.spriteVertexCount * skinData.spriteVertexStreamSize;
+            var deformVertices = m_DeformedVerticesBuffer.GetCurrentBuffer();
+            byte* ptrVertices = (byte*)deformVertices.GetUnsafeReadOnlyPtr();
+            ptrVertices += skinData.deformVerticesStartPos; 
+            var buffer = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<byte>(ptrVertices, vertexBufferLength, Allocator.None);
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref buffer, NativeArrayUnsafeUtility.GetAtomicSafetyHandle(deformVertices));
+#endif
+            return buffer;
+        }
+
+        // Code for tests
+        #region Code For Tests
+        internal string GetDebugLog()
+        {
+            var log = "";
+            log = "====SpriteSkinLateUpdate===\n";
+            log += "Count: " + m_SpriteSkinLateUpdate.Count +"\n";
+            foreach (var ss in m_SpriteSkinLateUpdate)
+            {
+                log += ss == null ? "null" : ss.name;
+                log += "\n";
+            }
+            log += "\n";
+
+            log += "===SpriteSkinBatch===\n";
+            log += "Count: " + m_SpriteSkins.Count +"\n";
+            foreach (var ss in m_SpriteSkins)
+            {
+                log += ss == null ? "null" : ss.name;
+                log += "\n";
+            }
+
+            log += "===LocalToWorldTransformAccessJob===\n";
+            log += m_LocalToWorldTransformAccessJob.GetDebugLog();
+            log += "\n";
+            log += "===WorldToLocalTransformAccessJob===\n";
+            log += "\n";
+            log += m_WorldToLocalTransformAccessJob.GetDebugLog();
+            return log;
+        }
+
+        internal SpriteSkin[] GetSpriteSkins()
+        {
+            return m_SpriteSkins.ToArray();
+        }
+
+        internal TransformAccessJob GetWorldToLocalTransformAccessJob()
+        {
+            return m_WorldToLocalTransformAccessJob;
+        }
+
+        internal TransformAccessJob GetLocalToWorldTransformAccessJob()
+        {
+            return m_LocalToWorldTransformAccessJob;
+        }
+        #endregion
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,263 @@
+#if ENABLE_ANIMATION_COLLECTION && ENABLE_ANIMATION_BURST
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Jobs;
+using Unity.Mathematics;
+using UnityEngine.Jobs;
+using UnityEngine.Profiling;
+using Unity.Burst;
+
+namespace UnityEngine.U2D.Animation
+{
+    internal class TransformAccessJob
+    {
+        internal struct TransformData
+        {
+            public int transformIndex;
+            public int refCount;
+
+            public TransformData(int index)
+            {
+                transformIndex = index;
+                refCount = 1;
+            }
+        }
+
+        Transform[] m_Transform;
+        TransformAccessArray m_TransformAccessArray;
+        NativeHashMap<int, TransformData> m_TransformData;
+        NativeArray<float4x4> m_TransformMatrix;
+        bool m_Dirty;
+        JobHandle m_JobHandle;
+
+        public TransformAccessJob()
+        {
+            m_TransformMatrix = new NativeArray<float4x4>(1, Allocator.Persistent);
+            m_TransformData  = new NativeHashMap<int, TransformData>(1, Allocator.Persistent);
+            m_Transform = new Transform[0];
+            m_Dirty = false;
+            m_JobHandle = default(JobHandle);
+        }
+
+        public void Destroy()
+        {
+            m_JobHandle.Complete();
+            if (m_TransformMatrix.IsCreated)
+                m_TransformMatrix.Dispose();
+            if (m_TransformAccessArray.isCreated)
+                m_TransformAccessArray.Dispose();
+            if (m_TransformData.IsCreated)
+                m_TransformData.Dispose();
+        }
+
+        public NativeHashMap<int, TransformData> transformData
+        {
+            get { return m_TransformData; }
+        }
+
+        public NativeArray<float4x4> transformMatrix
+        {
+            get { return m_TransformMatrix; }
+        }
+
+        public void AddTransform(Transform t)
+        {
+            if (t == null || !m_TransformData.IsCreated)
+                return;
+            m_JobHandle.Complete();
+            int instanceId = t.GetInstanceID();
+            if (m_TransformData.ContainsKey(instanceId))
+            {
+                var transformData = m_TransformData[instanceId];
+                transformData.refCount += 1;
+                m_TransformData[instanceId] = transformData;
+            }
+            else
+            {
+                m_TransformData.TryAdd(instanceId, new TransformData(-1));
+                ArrayAdd(ref m_Transform, t);
+                m_Dirty = true;
+            }
+
+        }
+
+        static void  ArrayAdd<T>(ref T[] array, T item)
+        {
+            int arraySize = array.Length;
+            Array.Resize(ref array, arraySize + 1);
+            array[arraySize] = item;
+        }
+
+        static void ArrayRemove<T>(ref T[] array, T item)
+        {
+            List<T> newList = new List<T>(array);
+            newList.Remove(item);
+            array = newList.ToArray();
+        }
+
+        public static void ArrayRemoveAt<T>(ref T[] array, int index)
+        {
+            List<T> list = new List<T>(array);
+            list.RemoveAt(index);
+            array = list.ToArray();
+        }
+
+        public void RemoveTransform(Transform t)
+        {
+            if (t == null || !m_TransformData.IsCreated)
+                return;
+            m_JobHandle.Complete();
+            int instanceId = t.GetInstanceID();
+            if (m_TransformData.ContainsKey(instanceId))
+            {
+                var transformData = m_TransformData[instanceId];
+                if (transformData.refCount == 1)
+                {
+                    m_TransformData.Remove(instanceId);
+                    ArrayRemove(ref m_Transform, t);
+                    m_Dirty = true;
+                }
+                else
+                {
+                    transformData.refCount -= 1;
+                    m_TransformData[instanceId] = transformData;
+                }
+            }
+        }
+
+        void UpdateTransformIndex()
+        {
+            if (!m_Dirty)
+                return;
+            m_Dirty = false;
+            Profiler.BeginSample("UpdateTransformIndex");
+            NativeArrayHelpers.ResizeIfNeeded(ref m_TransformMatrix, m_Transform.Length);
+            if (!m_TransformAccessArray.isCreated)
+                TransformAccessArray.Allocate(m_Transform.Length, -1, out m_TransformAccessArray);
+            else if (m_TransformAccessArray.capacity != m_Transform.Length)
+                m_TransformAccessArray.capacity = m_Transform.Length;
+            m_TransformAccessArray.SetTransforms(m_Transform);
+
+            for (int i = 0; i < m_Transform.Length; ++i)
+            {
+                if (m_Transform[i] != null)
+                {
+                    var instanceId = m_Transform[i].GetInstanceID();
+                    var transformData = m_TransformData[instanceId];
+                    transformData.transformIndex = i;
+                    m_TransformData[instanceId] = transformData;
+                }
+            }
+            Profiler.EndSample();
+        }
+
+        public JobHandle StartLocalToWorldJob()
+        {
+            if (m_Transform.Length > 0)
+            {
+                m_JobHandle.Complete();
+                UpdateTransformIndex();
+                Profiler.BeginSample("StartLocalToWorldJob");
+                var job = new LocalToWorldTransformAccessJob()
+                {
+                    outMatrix = transformMatrix,
+                };
+                m_JobHandle = job.Schedule(m_TransformAccessArray);
+                Profiler.EndSample();
+                return m_JobHandle;
+            }
+            
+            return default(JobHandle);
+        }
+
+        public JobHandle StartWorldToLocalJob()
+        {
+            if (m_Transform.Length > 0)
+            {
+                m_JobHandle.Complete();
+                UpdateTransformIndex();
+                Profiler.BeginSample("StartWorldToLocalJob");
+                var job = new WorldToLocalTransformAccessJob()
+                {
+                    outMatrix = transformMatrix,
+                };
+                m_JobHandle = job.Schedule(m_TransformAccessArray);
+                Profiler.EndSample();
+                return m_JobHandle;
+            }
+
+            return default(JobHandle);
+        }
+
+        internal string GetDebugLog()
+        {
+            var log = "";
+            log += "TransformData Count: " + m_TransformData.Count() + "\n";
+            log += "Transform Count: " + m_Transform.Length + "\n";
+            foreach (var ss in m_Transform)
+            {
+                log += ss == null ? "null" : ss.name + " " + ss.GetInstanceID();
+                log += "\n";
+                if (ss != null)
+                {
+                    log += "RefCount: " + m_TransformData[ss.GetInstanceID()].refCount + "\n";
+                }
+                
+                log += "\n";
+            }
+
+            return log;
+        }
+
+        internal void RemoveTransformById(int transformId)
+        {
+            if (!m_TransformData.IsCreated)
+                return;
+            m_JobHandle.Complete();
+            if (m_TransformData.ContainsKey(transformId))
+            {
+                var transformData = m_TransformData[transformId];
+                if (transformData.refCount == 1)
+                {
+                    m_TransformData.Remove(transformId);
+                    var index = Array.FindIndex(m_Transform, t => t.GetInstanceID() == transformId);
+                    if (index >= 0)
+                    {
+                        ArrayRemoveAt(ref m_Transform, index);
+                    }
+                    m_Dirty = true;
+                }
+                else
+                {
+                    transformData.refCount -= 1;
+                    m_TransformData[transformId] = transformData;
+                }
+            }
+        }
+    }
+    
+    [BurstCompile]
+    internal struct LocalToWorldTransformAccessJob : IJobParallelForTransform
+    {
+        [WriteOnly]
+        public NativeArray<float4x4> outMatrix;
+        public void Execute(int index, TransformAccess transform)
+        {
+            outMatrix[index] = transform.localToWorldMatrix;
+        }
+    }
+    
+    [BurstCompile]
+    internal struct WorldToLocalTransformAccessJob : IJobParallelForTransform
+    {
+        [WriteOnly]
+        public NativeArray<float4x4> outMatrix;
+        
+        public void Execute(int index, TransformAccess transform)
+        {
+            outMatrix[index] = transform.worldToLocalMatrix;
+        }
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 06a96291c7f2fc843851eece9bfd1097
+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/Runtime/Unity.2D.Animation.Runtime.asmdef

@@ -0,0 +1,35 @@
+{
+    "name": "Unity.2D.Animation.Runtime",
+    "rootNamespace": "",
+    "references": [
+        "Unity.2D.Common.Runtime",
+        "Unity.InternalAPIEngineBridge.001",
+        "Unity.Entities",
+        "Unity.Mathematics",
+        "Unity.Entities.Hybrid",
+        "Unity.Transforms",
+        "Unity.Transforms.Hybrid",
+        "Unity.Burst",
+        "Unity.Collections"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.burst",
+            "expression": "0.0.1",
+            "define": "ENABLE_ANIMATION_BURST"
+        },
+        {
+            "name": "com.unity.collections",
+            "expression": "0.9.0-preview.6",
+            "define": "ENABLE_ANIMATION_COLLECTION"
+        }
+    ],
+    "noEngineReferences": false
+}