Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/Handles/Shaders.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/Handles/ss_leftrange.png.meta

@@ -0,0 +1,91 @@
+fileFormatVersion: 2
+guid: 9417efc47083f4a1598c1966a6345cdb
+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: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 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
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    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.spriteshape@5.1.1/Editor/Handles/ss_playhead.png.meta

@@ -0,0 +1,91 @@
+fileFormatVersion: 2
+guid: 9ea72647c24be493ba6f15a9cd2a24ae
+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: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 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
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    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.spriteshape@5.1.1/Editor/Handles/ss_rightrange.png.meta

@@ -0,0 +1,91 @@
+fileFormatVersion: 2
+guid: ee5df01235032491c8b180741ea820fe
+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: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 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
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    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.spriteshape@5.1.1/Editor/Icons/SpriteShape@64.png.meta

@@ -0,0 +1,107 @@
+fileFormatVersion: 2
+guid: 0a9a0f36a52ce7f4d813fbf5d8f76a1c
+timeCreated: 1505457322
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 1
+    enableMipMap: 1
+    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
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/Icons/SpriteShapeController@64.png.meta

@@ -0,0 +1,107 @@
+fileFormatVersion: 2
+guid: d1508e1dc42abb745b24c8891a614d2a
+timeCreated: 1505457322
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 1
+    enableMipMap: 1
+    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
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/AssetCreation.cs

@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor.Presets;
+using UnityEditor.U2D.Common;
+using UnityEngine;
+
+namespace UnityEditor.U2D.SpriteShape
+{
+    internal static class AssetCreation
+    {
+        const int k_SpriteShapeAssetMenuPriority = 9;
+        static internal Action<int, ProjectWindowCallback.EndNameEditAction, string, Texture2D, string> StartNewAssetNameEditingDelegate = ProjectWindowUtil.StartNameEditingIfProjectWindowExists;
+        
+        [MenuItem("Assets/Create/2D/Sprite Shape Profile", priority = k_SpriteShapeAssetMenuPriority)]
+        static void MenuItem_AssetsCreate2DSpriteShapeProfile(MenuCommand menuCommand)
+        {
+            var asset = AssetDatabase.LoadAssetAtPath<UnityEngine.U2D.SpriteShape>("Packages/com.unity.2d.spriteshape/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shape Profiles/Sprite Shape Profile.asset");
+            var preset = new PresetType(asset);
+            var defaults = Preset.GetDefaultPresetsForType(preset).Count(x => x.enabled);
+            if (defaults == 0)
+                CreateAssetObject(asset);
+            else
+                CreateAssetObject<UnityEngine.U2D.SpriteShape>(null);
+        }
+        
+        static public T CreateAssetObject<T>(T obj) where T : UnityEngine.Object
+        {
+            var assetSelectionPath = AssetDatabase.GetAssetPath(Selection.activeObject);
+            var isFolder = false;
+            if(!string.IsNullOrEmpty(assetSelectionPath))
+                isFolder = File.GetAttributes(assetSelectionPath).HasFlag(FileAttributes.Directory);
+            var path = InternalEditorBridge.GetProjectWindowActiveFolderPath();
+            if (isFolder)
+            {
+                path = assetSelectionPath;
+            }
+
+            string resourceFile = "";
+            string destName = "";
+            int instanceId = 0;
+            string fileName = "";
+            if (obj != null)
+            {
+                resourceFile = AssetDatabase.GetAssetPath(obj);
+                fileName = System.IO.Path.GetFileName(resourceFile);
+            }
+            else
+            {
+                obj = ObjectFactory.CreateInstance<T>();
+                instanceId = obj.GetInstanceID();
+                fileName = "Sprite Shape Profile.asset";
+            }
+            destName = AssetDatabase.GenerateUniqueAssetPath(System.IO.Path.Combine(path, fileName));
+            var icon = AssetPreview.GetMiniThumbnail(obj);
+            StartNewAssetNameEditing(resourceFile, destName, icon, instanceId);
+            return Selection.activeObject as T;
+        }
+        
+        static private void StartNewAssetNameEditing(string source, string dest, Texture2D icon, int instanceId)
+        {
+            CreateAssetEndNameEditAction action = ScriptableObject.CreateInstance<CreateAssetEndNameEditAction>();
+            StartNewAssetNameEditingDelegate(instanceId, action, dest, icon, source);
+        }
+
+        internal class CreateAssetEndNameEditAction : ProjectWindowCallback.EndNameEditAction
+        {
+            public override void Action(int instanceId, string pathName, string resourceFile)
+            {
+                var uniqueName = AssetDatabase.GenerateUniqueAssetPath(pathName);
+                // ProjectWindowUtil.StartNameEditingIfProjectWindowExists(int instanceID, EndNameEditAction endAction, string pathName, Texture2D icon, string resourceFile)
+                // will reset the instanceId to Int32.MaxValue - 1 if its 0. Looks like a new trunk change ?
+                var validInstanceId = (instanceId != 0 && instanceId != InternalEditorBridge.GetAssetCreationInstanceID_ForNonExistingAssets());
+                if (!validInstanceId && !string.IsNullOrEmpty(resourceFile))
+                {
+                    AssetDatabase.CopyAsset(resourceFile, uniqueName);
+                }
+                else
+                {
+                    var obj = EditorUtility.InstanceIDToObject(instanceId);
+                    AssetDatabase.CreateAsset(obj, uniqueName);
+                }
+                
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/AssetCreation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f4901044050fd46e7a8c62a3da1f2c09
+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.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shape Profiles.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shapes.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shapes/Open Sprite Shape.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 86ae7de409eb54f619fb1328e4d42480
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shapes/SpriteShapeEdge.png.meta

@@ -0,0 +1,132 @@
+fileFormatVersion: 2
+guid: 0ae2b74b1edd14bb18dd7b65ae916a54
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  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: 256
+  spriteBorder: {x: 64, y: 0, z: 64, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  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.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Textures.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/GameObjectCreation.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Linq;
+using UnityEditor.Presets;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.U2D;
+
+namespace UnityEditor.U2D.SpriteShape
+{
+    class GameObjectCreation
+    {
+        const int k_MenuPriority = 4;
+        [MenuItem("GameObject/2D Object/Sprite Shape/Open Shape", false, k_MenuPriority)]
+        static void MenuItem_GameObject2DObjectSpriteShapeOpenShape(MenuCommand menuCommand)
+        {
+            var asset = AssetDatabase.LoadAssetAtPath<GameObject>("Packages/com.unity.2d.spriteshape/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shapes/Open Sprite Shape.prefab") as GameObject;
+            var preset = new PresetType(asset.GetComponent<SpriteShapeController>());
+            var defaults = Preset.GetDefaultPresetsForType(preset).Count(x => x.enabled);
+            if(defaults == 0)
+                CreateGameObjectFromTemplate(asset, menuCommand);
+            else
+            {
+                var go = CreateGameObject("Open Sprite Shape", menuCommand, new []{typeof(SpriteShapeController)});
+                go.GetComponent<SpriteShapeController>().spline.isOpenEnded = true;
+            }
+        }
+
+        [MenuItem("GameObject/2D Object/Sprite Shape/Closed Shape", false, k_MenuPriority)]
+        static void MenuItem_GameObject2DObjectSpriteShapeClosedShape(MenuCommand menuCommand)
+        {
+            var asset = AssetDatabase.LoadAssetAtPath<GameObject>("Packages/com.unity.2d.spriteshape/Editor/ObjectMenuCreation/DefaultAssets/Sprite Shapes/Closed Sprite Shape.prefab") as GameObject;
+            var preset = new PresetType(asset.GetComponent<SpriteShapeController>());
+            var defaults = Preset.GetDefaultPresetsForType(preset).Count(x => x.enabled);
+            if(defaults == 0)
+                CreateGameObjectFromTemplate(asset, menuCommand);
+            else
+            {
+                var go = CreateGameObject("Closed Sprite Shape", menuCommand, new []{typeof(SpriteShapeController)});
+                go.GetComponent<SpriteShapeController>().spline.isOpenEnded = false;
+            }
+        }
+        
+        static public GameObject CreateGameObjectFromTemplate(GameObject template, MenuCommand menuCommand)
+        {
+            var parent = menuCommand.context as GameObject;
+            var fileName = System.IO.Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(template));
+            var newGO = GameObject.Instantiate(template);
+            newGO.name = fileName;
+            Selection.activeObject = newGO;
+            Place(newGO, parent);
+            Undo.RegisterCreatedObjectUndo(newGO, string.Format("Create {0}", fileName));
+            return newGO;
+        }
+        
+        static public GameObject CreateGameObject(string name, MenuCommand menuCommand, params Type[] components)
+        {
+            var parent = menuCommand.context as GameObject;
+            var newGO = ObjectFactory.CreateGameObject(name, components);
+            newGO.name = name;
+            Selection.activeObject = newGO;
+            Place(newGO, parent);
+
+            Undo.RegisterCreatedObjectUndo(newGO, string.Format("Create {0}", name));
+            return newGO;
+        }
+        
+        internal static void Place(GameObject go, GameObject parentTransform)
+        {
+            if (parentTransform != null)
+            {
+                var transform = go.transform;
+                Undo.SetTransformParent(transform, parentTransform.transform, "Reparenting");
+                transform.localPosition = Vector3.zero;
+                transform.localRotation = Quaternion.identity;
+                transform.localScale = Vector3.one;
+                go.layer = parentTransform.gameObject.layer;
+
+                if (parentTransform.GetComponent<RectTransform>())
+                    ObjectFactory.AddComponent<RectTransform>(go);
+            }
+            else
+            {
+                PlaceGameObjectInFrontOfSceneView(go);
+
+                StageUtility.PlaceGameObjectInCurrentStage(go); // may change parent
+            }
+
+            // Only at this point do we know the actual parent of the object and can modify its name accordingly.
+            GameObjectUtility.EnsureUniqueNameForSibling(go);
+            Undo.SetCurrentGroupName("Create " + go.name);
+            Selection.activeGameObject = go;
+            if (EditorSettings.defaultBehaviorMode == EditorBehaviorMode.Mode2D)
+            {
+                var position = go.transform.position;
+                position.z = 0;
+                go.transform.position = position;
+            }
+        }
+        
+        internal static void PlaceGameObjectInFrontOfSceneView(GameObject go)
+        {
+            var view = SceneView.lastActiveSceneView;
+            if (view != null)
+            {
+                view.MoveToView(go.transform);
+            }
+        }
+    }
+}
+

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/GameObjectCreation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c0e71825dc37444988e41740332ff1bf
+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.spriteshape@5.1.1/Runtime/External/LibTessDotNet/LICENSE.txt.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Mesh.cs

@@ -0,0 +1,500 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Original Author: Eric Veach, July 1994.
+** libtess2: Mikko Mononen, http://code.google.com/p/libtess2/.
+** LibTessDotNet: Remi Gillig, https://github.com/speps/LibTessDotNet
+*/
+
+using System;
+using System.Diagnostics;
+
+namespace Unity.SpriteShape.External
+{
+
+namespace LibTessDotNet
+{
+    internal class Mesh : MeshUtils.Pooled<Mesh>
+    {
+        internal MeshUtils.Vertex _vHead;
+        internal MeshUtils.Face _fHead;
+        internal MeshUtils.Edge _eHead, _eHeadSym;
+
+        public Mesh()
+        {
+            var v = _vHead = MeshUtils.Vertex.Create();
+            var f = _fHead = MeshUtils.Face.Create();
+
+            var pair = MeshUtils.EdgePair.Create();
+            var e = _eHead = pair._e;
+            var eSym = _eHeadSym = pair._eSym;
+
+            v._next = v._prev = v;
+            v._anEdge = null;
+
+            f._next = f._prev = f;
+            f._anEdge = null;
+            f._trail = null;
+            f._marked = false;
+            f._inside = false;
+
+            e._next = e;
+            e._Sym = eSym;
+            e._Onext = null;
+            e._Lnext = null;
+            e._Org = null;
+            e._Lface = null;
+            e._winding = 0;
+            e._activeRegion = null;
+
+            eSym._next = eSym;
+            eSym._Sym = e;
+            eSym._Onext = null;
+            eSym._Lnext = null;
+            eSym._Org = null;
+            eSym._Lface = null;
+            eSym._winding = 0;
+            eSym._activeRegion = null;
+        }
+
+        public override void Reset()
+        {
+            _vHead = null;
+            _fHead = null;
+            _eHead = _eHeadSym = null;
+        }
+
+        public override void OnFree()
+        {
+            for (MeshUtils.Face f = _fHead._next, fNext = _fHead; f != _fHead; f = fNext)
+            {
+                fNext = f._next;
+                f.Free();
+            }
+            for (MeshUtils.Vertex v = _vHead._next, vNext = _vHead; v != _vHead; v = vNext)
+            {
+                vNext = v._next;
+                v.Free();
+            }
+            for (MeshUtils.Edge e = _eHead._next, eNext = _eHead; e != _eHead; e = eNext)
+            {
+                eNext = e._next;
+                e.Free();
+            }
+        }
+
+        /// <summary>
+        /// Creates one edge, two vertices and a loop (face).
+        /// The loop consists of the two new half-edges.
+        /// </summary>
+        public MeshUtils.Edge MakeEdge()
+        {
+            var e = MeshUtils.MakeEdge(_eHead);
+
+            MeshUtils.MakeVertex(e, _vHead);
+            MeshUtils.MakeVertex(e._Sym, _vHead);
+            MeshUtils.MakeFace(e, _fHead);
+
+            return e;
+        }
+
+        /// <summary>
+        /// Splice is the basic operation for changing the
+        /// mesh connectivity and topology.  It changes the mesh so that
+        ///     eOrg->Onext = OLD( eDst->Onext )
+        ///     eDst->Onext = OLD( eOrg->Onext )
+        /// where OLD(...) means the value before the meshSplice operation.
+        /// 
+        /// This can have two effects on the vertex structure:
+        ///  - if eOrg->Org != eDst->Org, the two vertices are merged together
+        ///  - if eOrg->Org == eDst->Org, the origin is split into two vertices
+        /// In both cases, eDst->Org is changed and eOrg->Org is untouched.
+        /// 
+        /// Similarly (and independently) for the face structure,
+        ///  - if eOrg->Lface == eDst->Lface, one loop is split into two
+        ///  - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one
+        /// In both cases, eDst->Lface is changed and eOrg->Lface is unaffected.
+        /// 
+        /// Some special cases:
+        /// If eDst == eOrg, the operation has no effect.
+        /// If eDst == eOrg->Lnext, the new face will have a single edge.
+        /// If eDst == eOrg->Lprev, the old face will have a single edge.
+        /// If eDst == eOrg->Onext, the new vertex will have a single edge.
+        /// If eDst == eOrg->Oprev, the old vertex will have a single edge.
+        /// </summary>
+        public void Splice(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
+        {
+            if (eOrg == eDst)
+            {
+                return;
+            }
+
+            bool joiningVertices = false;
+            if (eDst._Org != eOrg._Org)
+            {
+                // We are merging two disjoint vertices -- destroy eDst->Org
+                joiningVertices = true;
+                MeshUtils.KillVertex(eDst._Org, eOrg._Org);
+            }
+            bool joiningLoops = false;
+            if (eDst._Lface != eOrg._Lface)
+            {
+                // We are connecting two disjoint loops -- destroy eDst->Lface
+                joiningLoops = true;
+                MeshUtils.KillFace(eDst._Lface, eOrg._Lface);
+            }
+
+            // Change the edge structure
+            MeshUtils.Splice(eDst, eOrg);
+
+            if (!joiningVertices)
+            {
+                // We split one vertex into two -- the new vertex is eDst->Org.
+                // Make sure the old vertex points to a valid half-edge.
+                MeshUtils.MakeVertex(eDst, eOrg._Org);
+                eOrg._Org._anEdge = eOrg;
+            }
+            if (!joiningLoops)
+            {
+                // We split one loop into two -- the new loop is eDst->Lface.
+                // Make sure the old face points to a valid half-edge.
+                MeshUtils.MakeFace(eDst, eOrg._Lface);
+                eOrg._Lface._anEdge = eOrg;
+            }
+        }
+
+        /// <summary>
+        /// Removes the edge eDel. There are several cases:
+        /// if (eDel->Lface != eDel->Rface), we join two loops into one; the loop
+        /// eDel->Lface is deleted. Otherwise, we are splitting one loop into two;
+        /// the newly created loop will contain eDel->Dst. If the deletion of eDel
+        /// would create isolated vertices, those are deleted as well.
+        /// </summary>
+        public void Delete(MeshUtils.Edge eDel)
+        {
+            var eDelSym = eDel._Sym;
+
+            // First step: disconnect the origin vertex eDel->Org.  We make all
+            // changes to get a consistent mesh in this "intermediate" state.
+
+            bool joiningLoops = false;
+            if (eDel._Lface != eDel._Rface)
+            {
+                // We are joining two loops into one -- remove the left face
+                joiningLoops = true;
+                MeshUtils.KillFace(eDel._Lface, eDel._Rface);
+            }
+
+            if (eDel._Onext == eDel)
+            {
+                MeshUtils.KillVertex(eDel._Org, null);
+            }
+            else
+            {
+                // Make sure that eDel->Org and eDel->Rface point to valid half-edges
+                eDel._Rface._anEdge = eDel._Oprev;
+                eDel._Org._anEdge = eDel._Onext;
+
+                MeshUtils.Splice(eDel, eDel._Oprev);
+
+                if (!joiningLoops)
+                {
+                    // We are splitting one loop into two -- create a new loop for eDel.
+                    MeshUtils.MakeFace(eDel, eDel._Lface);
+                }
+            }
+
+            // Claim: the mesh is now in a consistent state, except that eDel->Org
+            // may have been deleted.  Now we disconnect eDel->Dst.
+
+            if (eDelSym._Onext == eDelSym)
+            {
+                MeshUtils.KillVertex(eDelSym._Org, null);
+                MeshUtils.KillFace(eDelSym._Lface, null);
+            }
+            else
+            {
+                // Make sure that eDel->Dst and eDel->Lface point to valid half-edges
+                eDel._Lface._anEdge = eDelSym._Oprev;
+                eDelSym._Org._anEdge = eDelSym._Onext;
+                MeshUtils.Splice(eDelSym, eDelSym._Oprev);
+            }
+
+            // Any isolated vertices or faces have already been freed.
+            MeshUtils.KillEdge(eDel);
+        }
+
+        /// <summary>
+        /// Creates a new edge such that eNew == eOrg.Lnext and eNew.Dst is a newly created vertex.
+        /// eOrg and eNew will have the same left face.
+        /// </summary>
+        public MeshUtils.Edge AddEdgeVertex(MeshUtils.Edge eOrg)
+        {
+            var eNew = MeshUtils.MakeEdge(eOrg);
+            var eNewSym = eNew._Sym;
+
+            // Connect the new edge appropriately
+            MeshUtils.Splice(eNew, eOrg._Lnext);
+
+            // Set vertex and face information
+            eNew._Org = eOrg._Dst;
+            MeshUtils.MakeVertex(eNewSym, eNew._Org);
+            eNew._Lface = eNewSym._Lface = eOrg._Lface;
+
+            return eNew;
+        }
+
+        /// <summary>
+        /// Splits eOrg into two edges eOrg and eNew such that eNew == eOrg.Lnext.
+        /// The new vertex is eOrg.Dst == eNew.Org.
+        /// eOrg and eNew will have the same left face.
+        /// </summary>
+        public MeshUtils.Edge SplitEdge(MeshUtils.Edge eOrg)
+        {
+            var eTmp = AddEdgeVertex(eOrg);
+            var eNew = eTmp._Sym;
+
+            // Disconnect eOrg from eOrg->Dst and connect it to eNew->Org
+            MeshUtils.Splice(eOrg._Sym, eOrg._Sym._Oprev);
+            MeshUtils.Splice(eOrg._Sym, eNew);
+
+            // Set the vertex and face information
+            eOrg._Dst = eNew._Org;
+            eNew._Dst._anEdge = eNew._Sym; // may have pointed to eOrg->Sym
+            eNew._Rface = eOrg._Rface;
+            eNew._winding = eOrg._winding; // copy old winding information
+            eNew._Sym._winding = eOrg._Sym._winding;
+
+            return eNew;
+        }
+
+        /// <summary>
+        /// Creates a new edge from eOrg->Dst to eDst->Org, and returns the corresponding half-edge eNew.
+        /// If eOrg->Lface == eDst->Lface, this splits one loop into two,
+        /// and the newly created loop is eNew->Lface.  Otherwise, two disjoint
+        /// loops are merged into one, and the loop eDst->Lface is destroyed.
+        /// 
+        /// If (eOrg == eDst), the new face will have only two edges.
+        /// If (eOrg->Lnext == eDst), the old face is reduced to a single edge.
+        /// If (eOrg->Lnext->Lnext == eDst), the old face is reduced to two edges.
+        /// </summary>
+        public MeshUtils.Edge Connect(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
+        {
+            var eNew = MeshUtils.MakeEdge(eOrg);
+            var eNewSym = eNew._Sym;
+
+            bool joiningLoops = false;
+            if (eDst._Lface != eOrg._Lface)
+            {
+                // We are connecting two disjoint loops -- destroy eDst->Lface
+                joiningLoops = true;
+                MeshUtils.KillFace(eDst._Lface, eOrg._Lface);
+            }
+
+            // Connect the new edge appropriately
+            MeshUtils.Splice(eNew, eOrg._Lnext);
+            MeshUtils.Splice(eNewSym, eDst);
+
+            // Set the vertex and face information
+            eNew._Org = eOrg._Dst;
+            eNewSym._Org = eDst._Org;
+            eNew._Lface = eNewSym._Lface = eOrg._Lface;
+
+            // Make sure the old face points to a valid half-edge
+            eOrg._Lface._anEdge = eNewSym;
+
+            if (!joiningLoops)
+            {
+                MeshUtils.MakeFace(eNew, eOrg._Lface);
+            }
+
+            return eNew;
+        }
+
+        /// <summary>
+        /// Destroys a face and removes it from the global face list. All edges of
+        /// fZap will have a NULL pointer as their left face. Any edges which
+        /// also have a NULL pointer as their right face are deleted entirely
+        /// (along with any isolated vertices this produces).
+        /// An entire mesh can be deleted by zapping its faces, one at a time,
+        /// in any order. Zapped faces cannot be used in further mesh operations!
+        /// </summary>
+        public void ZapFace(MeshUtils.Face fZap)
+        {
+            var eStart = fZap._anEdge;
+
+            // walk around face, deleting edges whose right face is also NULL
+            var eNext = eStart._Lnext;
+            MeshUtils.Edge e, eSym;
+            do {
+                e = eNext;
+                eNext = e._Lnext;
+
+                e._Lface = null;
+                if (e._Rface == null)
+                {
+                    // delete the edge -- see TESSmeshDelete above
+
+                    if (e._Onext == e)
+                    {
+                        MeshUtils.KillVertex(e._Org, null);
+                    }
+                    else
+                    {
+                        // Make sure that e._Org points to a valid half-edge
+                        e._Org._anEdge = e._Onext;
+                        MeshUtils.Splice(e, e._Oprev);
+                    }
+                    eSym = e._Sym;
+                    if (eSym._Onext == eSym)
+                    {
+                        MeshUtils.KillVertex(eSym._Org, null);
+                    }
+                    else
+                    {
+                        // Make sure that eSym._Org points to a valid half-edge
+                        eSym._Org._anEdge = eSym._Onext;
+                        MeshUtils.Splice(eSym, eSym._Oprev);
+                    }
+                    MeshUtils.KillEdge(e);
+                }
+            } while (e != eStart);
+
+            /* delete from circular doubly-linked list */
+            var fPrev = fZap._prev;
+            var fNext = fZap._next;
+            fNext._prev = fPrev;
+            fPrev._next = fNext;
+
+            fZap.Free();
+        }
+
+        public void MergeConvexFaces(int maxVertsPerFace)
+        {
+            for (var f = _fHead._next; f != _fHead; f = f._next)
+            {
+                // Skip faces which are outside the result
+                if (!f._inside)
+                {
+                    continue;
+                }
+
+                var eCur = f._anEdge;
+                var vStart = eCur._Org;
+
+                while (true)
+                {
+                    var eNext = eCur._Lnext;
+                    var eSym = eCur._Sym;
+
+                    if (eSym != null && eSym._Lface != null && eSym._Lface._inside)
+                    {
+                        // Try to merge the neighbour faces if the resulting polygons
+                        // does not exceed maximum number of vertices.
+                        int curNv = f.VertsCount;
+                        int symNv = eSym._Lface.VertsCount;
+                        if ((curNv + symNv - 2) <= maxVertsPerFace)
+                        {
+                            // Merge if the resulting poly is convex.
+                            if (Geom.VertCCW(eCur._Lprev._Org, eCur._Org, eSym._Lnext._Lnext._Org) &&
+                                Geom.VertCCW(eSym._Lprev._Org, eSym._Org, eCur._Lnext._Lnext._Org))
+                            {
+                                eNext = eSym._Lnext;
+                                Delete(eSym);
+                                eCur = null;
+                            }
+                        }
+                    }
+
+                    if (eCur != null && eCur._Lnext._Org == vStart)
+                        break;
+
+                    // Continue to next edge.
+                    eCur = eNext;
+                }
+            }
+        }
+
+        [Conditional("DEBUG")]
+        public void Check()
+        {
+            MeshUtils.Edge e;
+
+            MeshUtils.Face fPrev = _fHead, f;
+            for (fPrev = _fHead; (f = fPrev._next) != _fHead; fPrev = f)
+            {
+                e = f._anEdge;
+                do {
+                    Debug.Assert(e._Sym != e);
+                    Debug.Assert(e._Sym._Sym == e);
+                    Debug.Assert(e._Lnext._Onext._Sym == e);
+                    Debug.Assert(e._Onext._Sym._Lnext == e);
+                    Debug.Assert(e._Lface == f);
+                    e = e._Lnext;
+                } while (e != f._anEdge);
+            }
+            Debug.Assert(f._prev == fPrev && f._anEdge == null);
+
+            MeshUtils.Vertex vPrev = _vHead, v;
+            for (vPrev = _vHead; (v = vPrev._next) != _vHead; vPrev = v)
+            {
+                Debug.Assert(v._prev == vPrev);
+                e = v._anEdge;
+                do
+                {
+                    Debug.Assert(e._Sym != e);
+                    Debug.Assert(e._Sym._Sym == e);
+                    Debug.Assert(e._Lnext._Onext._Sym == e);
+                    Debug.Assert(e._Onext._Sym._Lnext == e);
+                    Debug.Assert(e._Org == v);
+                    e = e._Onext;
+                } while (e != v._anEdge);
+            }
+            Debug.Assert(v._prev == vPrev && v._anEdge == null);
+
+            MeshUtils.Edge ePrev = _eHead;
+            for (ePrev = _eHead; (e = ePrev._next) != _eHead; ePrev = e)
+            {
+                Debug.Assert(e._Sym._next == ePrev._Sym);
+                Debug.Assert(e._Sym != e);
+                Debug.Assert(e._Sym._Sym == e);
+                Debug.Assert(e._Org != null);
+                Debug.Assert(e._Dst != null);
+                Debug.Assert(e._Lnext._Onext._Sym == e);
+                Debug.Assert(e._Onext._Sym._Lnext == e);
+            }
+            Debug.Assert(e._Sym._next == ePrev._Sym
+                && e._Sym == _eHeadSym
+                && e._Sym._Sym == e
+                && e._Org == null && e._Dst == null
+                && e._Lface == null && e._Rface == null);
+        }
+    }
+}
+
+} // namespace Unity.VectorGraphics.External

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Tess.cs

@@ -0,0 +1,746 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Original Author: Eric Veach, July 1994.
+** libtess2: Mikko Mononen, http://code.google.com/p/libtess2/.
+** LibTessDotNet: Remi Gillig, https://github.com/speps/LibTessDotNet
+*/
+
+using System;
+using System.Diagnostics;
+
+namespace Unity.SpriteShape.External
+{
+
+using Real = System.Single;
+namespace LibTessDotNet
+{
+    internal enum WindingRule
+    {
+        EvenOdd,
+        NonZero,
+        Positive,
+        Negative,
+        AbsGeqTwo
+    }
+
+    internal enum ElementType
+    {
+        Polygons,
+        ConnectedPolygons,
+        BoundaryContours
+    }
+
+    internal enum ContourOrientation
+    {
+        Original,
+        Clockwise,
+        CounterClockwise
+    }
+
+    internal struct ContourVertex
+    {
+        public Vec3 Position;
+        public object Data;
+
+        public override string ToString()
+        {
+            return string.Format("{0}, {1}", Position, Data);
+        }
+    }
+
+    internal delegate object CombineCallback(Vec3 position, object[] data, Real[] weights);
+
+    internal partial class Tess
+    {
+        private Mesh _mesh;
+        private Vec3 _normal;
+        private Vec3 _sUnit;
+        private Vec3 _tUnit;
+
+        private Real _bminX, _bminY, _bmaxX, _bmaxY;
+
+        private WindingRule _windingRule;
+
+        private Dict<ActiveRegion> _dict;
+        private PriorityQueue<MeshUtils.Vertex> _pq;
+        private MeshUtils.Vertex _event;
+
+        private CombineCallback _combineCallback;
+
+        private ContourVertex[] _vertices;
+        private int _vertexCount;
+        private int[] _elements;
+        private int _elementCount;
+
+        public Vec3 Normal { get { return _normal; } set { _normal = value; } }
+
+        public Real SUnitX = 1;
+        public Real SUnitY = 0;
+        public Real SentinelCoord = 4e30f;
+
+        /// <summary>
+        /// If true, will remove empty (zero area) polygons.
+        /// </summary>
+        public bool NoEmptyPolygons = false;
+
+        /// <summary>
+        /// If true, will use pooling to reduce GC (compare performance with/without, can vary wildly).
+        /// </summary>
+        public bool UsePooling = false;
+
+        public ContourVertex[] Vertices { get { return _vertices; } }
+        public int VertexCount { get { return _vertexCount; } }
+
+        public int[] Elements { get { return _elements; } }
+        public int ElementCount { get { return _elementCount; } }
+
+        public Tess()
+        {
+            _normal = Vec3.Zero;
+            _bminX = _bminY = _bmaxX = _bmaxY = 0;
+
+            _windingRule = WindingRule.EvenOdd;
+            _mesh = null;
+
+            _vertices = null;
+            _vertexCount = 0;
+            _elements = null;
+            _elementCount = 0;
+        }
+
+        private void ComputeNormal(ref Vec3 norm)
+        {
+            var v = _mesh._vHead._next;
+
+            var minVal = new Real[3] { v._coords.X, v._coords.Y, v._coords.Z };
+            var minVert = new MeshUtils.Vertex[3] { v, v, v };
+            var maxVal = new Real[3] { v._coords.X, v._coords.Y, v._coords.Z };
+            var maxVert = new MeshUtils.Vertex[3] { v, v, v };
+
+            for (; v != _mesh._vHead; v = v._next)
+            {
+                if (v._coords.X < minVal[0]) { minVal[0] = v._coords.X; minVert[0] = v; }
+                if (v._coords.Y < minVal[1]) { minVal[1] = v._coords.Y; minVert[1] = v; }
+                if (v._coords.Z < minVal[2]) { minVal[2] = v._coords.Z; minVert[2] = v; }
+                if (v._coords.X > maxVal[0]) { maxVal[0] = v._coords.X; maxVert[0] = v; }
+                if (v._coords.Y > maxVal[1]) { maxVal[1] = v._coords.Y; maxVert[1] = v; }
+                if (v._coords.Z > maxVal[2]) { maxVal[2] = v._coords.Z; maxVert[2] = v; }
+            }
+
+            // Find two vertices separated by at least 1/sqrt(3) of the maximum
+            // distance between any two vertices
+            int i = 0;
+            if (maxVal[1] - minVal[1] > maxVal[0] - minVal[0]) { i = 1; }
+            if (maxVal[2] - minVal[2] > maxVal[i] - minVal[i]) { i = 2; }
+            if (minVal[i] >= maxVal[i])
+            {
+                // All vertices are the same -- normal doesn't matter
+                norm = new Vec3 { X = 0, Y = 0, Z = 1 };
+                return;
+            }
+
+            // Look for a third vertex which forms the triangle with maximum area
+            // (Length of normal == twice the triangle area)
+            Real maxLen2 = 0, tLen2;
+            var v1 = minVert[i];
+            var v2 = maxVert[i];
+            Vec3 d1, d2, tNorm;
+            Vec3.Sub(ref v1._coords, ref v2._coords, out d1);
+            for (v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+            {
+                Vec3.Sub(ref v._coords, ref v2._coords, out d2);
+                tNorm.X = d1.Y * d2.Z - d1.Z * d2.Y;
+                tNorm.Y = d1.Z * d2.X - d1.X * d2.Z;
+                tNorm.Z = d1.X * d2.Y - d1.Y * d2.X;
+                tLen2 = tNorm.X*tNorm.X + tNorm.Y*tNorm.Y + tNorm.Z*tNorm.Z;
+                if (tLen2 > maxLen2)
+                {
+                    maxLen2 = tLen2;
+                    norm = tNorm;
+                }
+            }
+
+            if (maxLen2 <= 0.0f)
+            {
+                // All points lie on a single line -- any decent normal will do
+                norm = Vec3.Zero;
+                i = Vec3.LongAxis(ref d1);
+                norm[i] = 1;
+            }
+        }
+
+        private void CheckOrientation()
+        {
+            // When we compute the normal automatically, we choose the orientation
+            // so that the the sum of the signed areas of all contours is non-negative.
+            Real area = 0.0f;
+            for (var f = _mesh._fHead._next; f != _mesh._fHead; f = f._next)
+            {
+                if (f._anEdge._winding <= 0)
+                {
+                    continue;
+                }
+                area += MeshUtils.FaceArea(f);
+            }
+            if (area < 0.0f)
+            {
+                // Reverse the orientation by flipping all the t-coordinates
+                for (var v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+                {
+                    v._t = -v._t;
+                }
+                Vec3.Neg(ref _tUnit);
+            }
+        }
+
+        private void ProjectPolygon()
+        {
+            var norm = _normal;
+
+            bool computedNormal = false;
+            if (norm.X == 0.0f && norm.Y == 0.0f && norm.Z == 0.0f)
+            {
+                ComputeNormal(ref norm);
+                _normal = norm;
+                computedNormal = true;
+            }
+
+            int i = Vec3.LongAxis(ref norm);
+
+            _sUnit[i] = 0;
+            _sUnit[(i + 1) % 3] = SUnitX;
+            _sUnit[(i + 2) % 3] = SUnitY;
+
+            _tUnit[i] = 0;
+            _tUnit[(i + 1) % 3] = norm[i] > 0.0f ? -SUnitY : SUnitY;
+            _tUnit[(i + 2) % 3] = norm[i] > 0.0f ? SUnitX : -SUnitX;
+
+            // Project the vertices onto the sweep plane
+            for (var v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+            {
+                Vec3.Dot(ref v._coords, ref _sUnit, out v._s);
+                Vec3.Dot(ref v._coords, ref _tUnit, out v._t);
+            }
+            if (computedNormal)
+            {
+                CheckOrientation();
+            }
+
+            // Compute ST bounds.
+            bool first = true;
+            for (var v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+            {
+                if (first)
+                {
+                    _bminX = _bmaxX = v._s;
+                    _bminY = _bmaxY = v._t;
+                    first = false;
+                }
+                else
+                {
+                    if (v._s < _bminX) _bminX = v._s;
+                    if (v._s > _bmaxX) _bmaxX = v._s;
+                    if (v._t < _bminY) _bminY = v._t;
+                    if (v._t > _bmaxY) _bmaxY = v._t;
+                }
+            }
+        }
+
+        /// <summary>
+        /// TessellateMonoRegion( face ) tessellates a monotone region
+        /// (what else would it do??)  The region must consist of a single
+        /// loop of half-edges (see mesh.h) oriented CCW.  "Monotone" in this
+        /// case means that any vertical line intersects the interior of the
+        /// region in a single interval.  
+        /// 
+        /// Tessellation consists of adding interior edges (actually pairs of
+        /// half-edges), to split the region into non-overlapping triangles.
+        /// 
+        /// The basic idea is explained in Preparata and Shamos (which I don't
+        /// have handy right now), although their implementation is more
+        /// complicated than this one.  The are two edge chains, an upper chain
+        /// and a lower chain.  We process all vertices from both chains in order,
+        /// from right to left.
+        /// 
+        /// The algorithm ensures that the following invariant holds after each
+        /// vertex is processed: the untessellated region consists of two
+        /// chains, where one chain (say the upper) is a single edge, and
+        /// the other chain is concave.  The left vertex of the single edge
+        /// is always to the left of all vertices in the concave chain.
+        /// 
+        /// Each step consists of adding the rightmost unprocessed vertex to one
+        /// of the two chains, and forming a fan of triangles from the rightmost
+        /// of two chain endpoints.  Determining whether we can add each triangle
+        /// to the fan is a simple orientation test.  By making the fan as large
+        /// as possible, we restore the invariant (check it yourself).
+        /// </summary>
+        private void TessellateMonoRegion(MeshUtils.Face face)
+        {
+            // All edges are oriented CCW around the boundary of the region.
+            // First, find the half-edge whose origin vertex is rightmost.
+            // Since the sweep goes from left to right, face->anEdge should
+            // be close to the edge we want.
+            var up = face._anEdge;
+            Debug.Assert(up._Lnext != up && up._Lnext._Lnext != up);
+
+            while (Geom.VertLeq(up._Dst, up._Org)) up = up._Lprev;
+            while (Geom.VertLeq(up._Org, up._Dst)) up = up._Lnext;
+
+            var lo = up._Lprev;
+
+            while (up._Lnext != lo)
+            {
+                if (Geom.VertLeq(up._Dst, lo._Org))
+                {
+                    // up.Dst is on the left. It is safe to form triangles from lo.Org.
+                    // The EdgeGoesLeft test guarantees progress even when some triangles
+                    // are CW, given that the upper and lower chains are truly monotone.
+                    while (lo._Lnext != up && (Geom.EdgeGoesLeft(lo._Lnext)
+                        || Geom.EdgeSign(lo._Org, lo._Dst, lo._Lnext._Dst) <= 0.0f))
+                    {
+                        lo = _mesh.Connect(lo._Lnext, lo)._Sym;
+                    }
+                    lo = lo._Lprev;
+                }
+                else
+                {
+                    // lo.Org is on the left.  We can make CCW triangles from up.Dst.
+                    while (lo._Lnext != up && (Geom.EdgeGoesRight(up._Lprev)
+                        || Geom.EdgeSign(up._Dst, up._Org, up._Lprev._Org) >= 0.0f))
+                    {
+                        up = _mesh.Connect(up, up._Lprev)._Sym;
+                    }
+                    up = up._Lnext;
+                }
+            }
+
+            // Now lo.Org == up.Dst == the leftmost vertex.  The remaining region
+            // can be tessellated in a fan from this leftmost vertex.
+            Debug.Assert(lo._Lnext != up);
+            while (lo._Lnext._Lnext != up)
+            {
+                lo = _mesh.Connect(lo._Lnext, lo)._Sym;
+            }
+        }
+
+        /// <summary>
+        /// TessellateInterior( mesh ) tessellates each region of
+        /// the mesh which is marked "inside" the polygon. Each such region
+        /// must be monotone.
+        /// </summary>
+        private void TessellateInterior()
+        {
+            MeshUtils.Face f, next;
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = next)
+            {
+                // Make sure we don't try to tessellate the new triangles.
+                next = f._next;
+                if (f._inside)
+                {
+                    TessellateMonoRegion(f);
+                }
+            }
+        }
+
+        /// <summary>
+        /// DiscardExterior zaps (ie. sets to null) all faces
+        /// which are not marked "inside" the polygon.  Since further mesh operations
+        /// on NULL faces are not allowed, the main purpose is to clean up the
+        /// mesh so that exterior loops are not represented in the data structure.
+        /// </summary>
+        private void DiscardExterior()
+        {
+            MeshUtils.Face f, next;
+
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = next)
+            {
+                // Since f will be destroyed, save its next pointer.
+                next = f._next;
+                if( ! f._inside ) {
+                    _mesh.ZapFace(f);
+                }
+            }
+        }
+
+        /// <summary>
+        /// SetWindingNumber( value, keepOnlyBoundary ) resets the
+        /// winding numbers on all edges so that regions marked "inside" the
+        /// polygon have a winding number of "value", and regions outside
+        /// have a winding number of 0.
+        /// 
+        /// If keepOnlyBoundary is TRUE, it also deletes all edges which do not
+        /// separate an interior region from an exterior one.
+        /// </summary>
+        private void SetWindingNumber(int value, bool keepOnlyBoundary)
+        {
+            MeshUtils.Edge e, eNext;
+
+            for (e = _mesh._eHead._next; e != _mesh._eHead; e = eNext)
+            {
+                eNext = e._next;
+                if (e._Rface._inside != e._Lface._inside)
+                {
+
+                    /* This is a boundary edge (one side is interior, one is exterior). */
+                    e._winding = (e._Lface._inside) ? value : -value;
+                }
+                else
+                {
+
+                    /* Both regions are interior, or both are exterior. */
+                    if (!keepOnlyBoundary)
+                    {
+                        e._winding = 0;
+                    }
+                    else
+                    {
+                        _mesh.Delete(e);
+                    }
+                }
+            }
+
+        }
+
+        private int GetNeighbourFace(MeshUtils.Edge edge)
+        {
+            if (edge._Rface == null)
+                return MeshUtils.Undef;
+            if (!edge._Rface._inside)
+                return MeshUtils.Undef;
+            return edge._Rface._n;
+        }
+
+        private void OutputPolymesh(ElementType elementType, int polySize)
+        {
+            MeshUtils.Vertex v;
+            MeshUtils.Face f;
+            MeshUtils.Edge edge;
+            int maxFaceCount = 0;
+            int maxVertexCount = 0;
+            int faceVerts, i;
+
+            if (polySize < 3)
+            {
+                polySize = 3;
+            }
+            // Assume that the input data is triangles now.
+            // Try to merge as many polygons as possible
+            if (polySize > 3)
+            {
+                _mesh.MergeConvexFaces(polySize);
+            }
+
+            // Mark unused
+            for (v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+                v._n = MeshUtils.Undef;
+
+            // Create unique IDs for all vertices and faces.
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = f._next)
+            {
+                f._n = MeshUtils.Undef;
+                if (!f._inside) continue;
+
+                if (NoEmptyPolygons)
+                {
+                    var area = MeshUtils.FaceArea(f);
+                    if (Math.Abs(area) < Real.Epsilon)
+                    {
+                        continue;
+                    }
+                }
+
+                edge = f._anEdge;
+                faceVerts = 0;
+                do {
+                    v = edge._Org;
+                    if (v._n == MeshUtils.Undef)
+                    {
+                        v._n = maxVertexCount;
+                        maxVertexCount++;
+                    }
+                    faceVerts++;
+                    edge = edge._Lnext;
+                }
+                while (edge != f._anEdge);
+
+                Debug.Assert(faceVerts <= polySize);
+
+                f._n = maxFaceCount;
+                ++maxFaceCount;
+            }
+
+            _elementCount = maxFaceCount;
+            if (elementType == ElementType.ConnectedPolygons)
+                maxFaceCount *= 2;
+            _elements = new int[maxFaceCount * polySize];
+
+            _vertexCount = maxVertexCount;
+            _vertices = new ContourVertex[_vertexCount];
+
+            // Output vertices.
+            for (v = _mesh._vHead._next; v != _mesh._vHead; v = v._next)
+            {
+                if (v._n != MeshUtils.Undef)
+                {
+                    // Store coordinate
+                    _vertices[v._n].Position = v._coords;
+                    _vertices[v._n].Data = v._data;
+                }
+            }
+
+            // Output indices.
+            int elementIndex = 0;
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = f._next)
+            {
+                if (!f._inside) continue;
+
+                if (NoEmptyPolygons)
+                {
+                    var area = MeshUtils.FaceArea(f);
+                    if (Math.Abs(area) < Real.Epsilon)
+                    {
+                        continue;
+                    }
+                }
+
+                // Store polygon
+                edge = f._anEdge;
+                faceVerts = 0;
+                do {
+                    v = edge._Org;
+                    _elements[elementIndex++] = v._n;
+                    faceVerts++;
+                    edge = edge._Lnext;
+                } while (edge != f._anEdge);
+                // Fill unused.
+                for (i = faceVerts; i < polySize; ++i)
+                {
+                    _elements[elementIndex++] = MeshUtils.Undef;
+                }
+
+                // Store polygon connectivity
+                if (elementType == ElementType.ConnectedPolygons)
+                {
+                    edge = f._anEdge;
+                    do
+                    {
+                        _elements[elementIndex++] = GetNeighbourFace(edge);
+                        edge = edge._Lnext;
+                    } while (edge != f._anEdge);
+                    // Fill unused.
+                    for (i = faceVerts; i < polySize; ++i)
+                    {
+                        _elements[elementIndex++] = MeshUtils.Undef;
+                    }
+                }
+            }
+        }
+
+        private void OutputContours()
+        {
+            MeshUtils.Face f;
+            MeshUtils.Edge edge, start;
+            int startVert = 0;
+            int vertCount = 0;
+
+            _vertexCount = 0;
+            _elementCount = 0;
+
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = f._next)
+            {
+                if (!f._inside) continue;
+
+                start = edge = f._anEdge;
+                do
+                {
+                    ++_vertexCount;
+                    edge = edge._Lnext;
+                }
+                while (edge != start);
+
+                ++_elementCount;
+            }
+
+            _elements = new int[_elementCount * 2];
+            _vertices = new ContourVertex[_vertexCount];
+
+            int vertIndex = 0;
+            int elementIndex = 0;
+
+            startVert = 0;
+
+            for (f = _mesh._fHead._next; f != _mesh._fHead; f = f._next)
+            {
+                if (!f._inside) continue;
+
+                vertCount = 0;
+                start = edge = f._anEdge;
+                do {
+                    _vertices[vertIndex].Position = edge._Org._coords;
+                    _vertices[vertIndex].Data = edge._Org._data;
+                    ++vertIndex;
+                    ++vertCount;
+                    edge = edge._Lnext;
+                } while (edge != start);
+
+                _elements[elementIndex++] = startVert;
+                _elements[elementIndex++] = vertCount;
+
+                startVert += vertCount;
+            }
+        }
+
+        private Real SignedArea(ContourVertex[] vertices)
+        {
+            Real area = 0.0f;
+
+            for (int i = 0; i < vertices.Length; i++)
+            {
+                var v0 = vertices[i];
+                var v1 = vertices[(i + 1) % vertices.Length];
+
+                area += v0.Position.X * v1.Position.Y;
+                area -= v0.Position.Y * v1.Position.X;
+            }
+
+            return 0.5f * area;
+        }
+
+        public void AddContour(ContourVertex[] vertices)
+        {
+            AddContour(vertices, ContourOrientation.Original);
+        }
+
+        public void AddContour(ContourVertex[] vertices, ContourOrientation forceOrientation)
+        {
+            if (_mesh == null)
+            {
+                _mesh = new Mesh();
+            }
+
+            bool reverse = false;
+            if (forceOrientation != ContourOrientation.Original)
+            {
+                var area = SignedArea(vertices);
+                reverse = (forceOrientation == ContourOrientation.Clockwise && area < 0.0f) || (forceOrientation == ContourOrientation.CounterClockwise && area > 0.0f);
+            }
+
+            MeshUtils.Edge e = null;
+            for (int i = 0; i < vertices.Length; ++i)
+            {
+                if (e == null)
+                {
+                    e = _mesh.MakeEdge();
+                    _mesh.Splice(e, e._Sym);
+                }
+                else
+                {
+                    // Create a new vertex and edge which immediately follow e
+                    // in the ordering around the left face.
+                    _mesh.SplitEdge(e);
+                    e = e._Lnext;
+                }
+
+                int index = reverse ? vertices.Length - 1 - i : i;
+                // The new vertex is now e._Org.
+                e._Org._coords = vertices[index].Position;
+                e._Org._data = vertices[index].Data;
+
+                // The winding of an edge says how the winding number changes as we
+                // cross from the edge's right face to its left face.  We add the
+                // vertices in such an order that a CCW contour will add +1 to
+                // the winding number of the region inside the contour.
+                e._winding = 1;
+                e._Sym._winding = -1;
+            }
+        }
+
+        public void Tessellate(WindingRule windingRule, ElementType elementType, int polySize)
+        {
+            Tessellate(windingRule, elementType, polySize, null);
+        }
+
+        public void Tessellate(WindingRule windingRule, ElementType elementType, int polySize, CombineCallback combineCallback)
+        {
+            _normal = Vec3.Zero;
+            _vertices = null;
+            _elements = null;
+
+            _windingRule = windingRule;
+            _combineCallback = combineCallback;
+
+            if (_mesh == null)
+            {
+                return;
+            }
+
+            // Determine the polygon normal and project vertices onto the plane
+            // of the polygon.
+            ProjectPolygon();
+
+            // ComputeInterior computes the planar arrangement specified
+            // by the given contours, and further subdivides this arrangement
+            // into regions.  Each region is marked "inside" if it belongs
+            // to the polygon, according to the rule given by windingRule.
+            // Each interior region is guaranteed be monotone.
+            ComputeInterior();
+
+            // If the user wants only the boundary contours, we throw away all edges
+            // except those which separate the interior from the exterior.
+            // Otherwise we tessellate all the regions marked "inside".
+            if (elementType == ElementType.BoundaryContours)
+            {
+                SetWindingNumber(1, true);
+            }
+            else
+            {
+                TessellateInterior();
+            }
+
+            _mesh.Check();
+
+            if (elementType == ElementType.BoundaryContours)
+            {
+                OutputContours();
+            }
+            else
+            {
+                OutputPolymesh(elementType, polySize);
+            }
+
+            if (UsePooling)
+            {
+                _mesh.Free();
+            }
+            _mesh = null;
+        }
+    }
+}
+
+} // namespace Unity.VectorGraphics.External

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Tess.cs.meta

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