Initial commit

Library/PackageCache/com.unity.2d.common@2.1.0/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## [2.1.0] - 2020-11-16
+###Changed
+- Minor version bump due to change in required Unity version
+
+## [2.0.3] - 2020-08-10
+### Fixed
+- Added missing UIElement dependency
+
+## [2.0.2] - 2019-08-09
+### Added
+- Add Seconday Texture settings into TextureSettings for TextureGenerator
+- Add related test packages
+
+## [2.0.1] - 2019-07-13
+### Changed
+- Mark package to support Unity 2019.3.0a10 onwards.
+
+## [2.0.0] - 2019-06-17
+### Added
+- Drop preview tag.
+- Remove experimental namespace
+
+## [1.2.0-preview.2] - 2019-06-04
+### Added
+- Remove Image Packer Debug Window
+- Move tests out of package
+
+## [1.2.0-preview.1] - 2019-02-20
+### Added
+- Update for Unity 2019.2 support.
+
+## [1.1.0-preview.2] - 2019-03-18
+### Added
+- Remove deprecated call to Unity internal API
+
+## [1.1.0-preview.1] - 2019-01-25
+### Added
+- Added versioning for CI.

Library/PackageCache/com.unity.2d.common@2.1.0/CHANGELOG.md.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Documentation~/Common.md

@@ -0,0 +1,5 @@
+2D Common
+
+# Overview
+
+This package contains shared code used by various 2D projects such as SpriteShape, Animation etc..

Library/PackageCache/com.unity.2d.common@2.1.0/Editor.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("Unity.2D.Common.Tests.EditorTests")]
+[assembly: InternalsVisibleTo("Unity.2D.PsdImporter.Editor")]

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePackNode.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Common
+{
+    internal interface IImagePackNodeVisitor
+    {
+        void Visit(ImagePackNode node);
+    }
+
+    class CollectEmptyNodePositionVisitor : IImagePackNodeVisitor
+    {
+        public List<RectInt> emptyAreas = new List<RectInt>();
+        public void Visit(ImagePackNode node)
+        {
+            if (node.imageId == -1)
+            {
+                emptyAreas.Add(node.rect);
+            }
+        }
+    }
+
+    class CollectPackNodePositionVisitor : IImagePackNodeVisitor
+    {
+        public CollectPackNodePositionVisitor()
+        {
+            positions = new Vector2Int[0];
+        }
+
+        public void Visit(ImagePackNode node)
+        {
+            if (node.imageId != -1)
+            {
+                if (positions.Length < node.imageId + 1)
+                {
+                    var p = positions;
+                    Array.Resize(ref p, node.imageId + 1);
+                    positions = p;
+                }
+
+                positions[node.imageId].x = node.rect.x;
+                positions[node.imageId].y = node.rect.y;
+            }
+        }
+
+        public Vector2Int[] positions { get; private set; }
+    }
+
+    internal class ImagePackNode
+    {
+        public ImagePackNode left;
+        public ImagePackNode right;
+        public RectInt rect;
+        public Vector2Int imageWidth;
+        public int imageId = -1;
+
+        public void AcceptVisitor(IImagePackNodeVisitor visitor)
+        {
+            visitor.Visit(this);
+            if (left != null)
+                left.AcceptVisitor(visitor);
+            if (right != null)
+                right.AcceptVisitor(visitor);
+        }
+
+        public void AdjustSize(int oriWidth, int oriHeight, int deltaW, int deltaH, out int adjustx, out int adjusty)
+        {
+            adjustx = adjusty = 0;
+            int adjustXleft = 0, adjustYleft = 0, adjustXRight = 0, adjustYRight = 0;
+            if (imageId == -1 || left == null)
+            {
+                if (rect.x + rect.width == oriWidth)
+                {
+                    rect.width += deltaW;
+                    adjustx = deltaW;
+                }
+                if (rect.y + rect.height == oriHeight)
+                {
+                    rect.height += deltaH;
+                    adjusty = deltaH;
+                }
+            }
+            else
+            {
+                left.AdjustSize(oriWidth, oriHeight, deltaW, deltaH, out adjustXleft, out adjustYleft);
+                right.AdjustSize(oriWidth, oriHeight, deltaW, deltaH, out adjustXRight, out adjustYRight);
+
+                adjustx = Mathf.Max(adjustXleft, adjustXRight);
+                rect.width += adjustx;
+                adjusty = Mathf.Max(adjustYleft, adjustYRight);
+                rect.height += adjusty;
+            }
+        }
+
+        public bool TryInsert(ImagePacker.ImagePackRect insert, int padding, out Vector2Int remainingSpace)
+        {
+            remainingSpace = Vector2Int.zero;
+            int insertWidth = insert.rect.width + padding * 2;
+            int insertHeight = insert.rect.height + padding * 2;
+            if (insertWidth > rect.width || insertHeight > rect.height)
+                return false;
+
+            if (imageId == -1)
+            {
+                remainingSpace.x = rect.width - insertWidth;
+                remainingSpace.y = rect.height - insertHeight;
+            }
+            else
+            {
+                Vector2Int spaceLeft, spaceRight;
+                bool insertLeft, insertRight;
+                ImagePackNode tryLeft, tryRight;
+                tryLeft = left;
+                tryRight = right;
+                if (left == null && !SplitRects(this, insert, padding, out tryLeft, out tryRight))
+                {
+                    return false;
+                }
+
+                insertLeft = tryLeft.TryInsert(insert, padding, out spaceLeft);
+                insertRight = tryRight.TryInsert(insert, padding, out spaceRight);
+                if (insertLeft && insertRight)
+                {
+                    remainingSpace = spaceLeft.sqrMagnitude < spaceRight.sqrMagnitude ? spaceLeft : spaceRight;
+                }
+                else if (insertLeft)
+                    remainingSpace = spaceLeft;
+                else if (insertRight)
+                    remainingSpace = spaceRight;
+                else
+                    return false;
+            }
+
+            return true;
+        }
+
+        static bool SplitRects(ImagePackNode node, ImagePacker.ImagePackRect insert, int padding, out ImagePackNode left, out ImagePackNode right)
+        {
+            // Find the best way to split the rect based on a new rect
+            left = right = null;
+            var tryRects = new[]
+            {
+                new ImagePackNode(), new ImagePackNode(),
+                new ImagePackNode(), new ImagePackNode()
+            };
+
+            tryRects[0].rect = new RectInt(node.rect.x + node.imageWidth.x, node.rect.y, node.rect.width - node.imageWidth.x, node.rect.height);
+            tryRects[1].rect = new RectInt(node.rect.x, node.rect.y + node.imageWidth.y, node.imageWidth.x, node.rect.height - node.imageWidth.y);
+            tryRects[2].rect = new RectInt(node.rect.x, node.rect.y + node.imageWidth.y, node.rect.width, node.rect.height - node.imageWidth.y);
+            tryRects[3].rect = new RectInt(node.rect.x + node.imageWidth.x, node.rect.y, node.rect.width - node.imageWidth.x, node.imageWidth.y);
+            float smallestSpace = float.MinValue;
+            for (int i = 0; i < tryRects.GetLength(0); ++i)
+            {
+                //for (int j = 0; j < tryRects.GetLength(1); ++j)
+                {
+                    Vector2Int newSpaceLeft;
+                    if (tryRects[i].TryInsert(insert, padding, out newSpaceLeft))
+                    {
+                        if (smallestSpace < newSpaceLeft.sqrMagnitude)
+                        {
+                            smallestSpace = newSpaceLeft.sqrMagnitude;
+                            int index = i / 2 * 2;
+                            left = tryRects[index];
+                            right = tryRects[index + 1];
+                        }
+                    }
+                }
+            }
+            return left != null;
+        }
+
+        public bool Insert(ImagePacker.ImagePackRect insert, int padding)
+        {
+            int insertWidth = insert.rect.width + padding * 2;
+            int insertHeight = insert.rect.height + padding * 2;
+            if (insertWidth > rect.width || insertHeight > rect.height)
+                return false;
+
+            if (imageId == -1)
+            {
+                imageId = insert.index;
+                imageWidth = new Vector2Int(insertWidth, insertHeight);
+            }
+            else
+            {
+                if (left == null && !SplitRects(this, insert, padding, out left, out right))
+                {
+                    return false;
+                }
+                // We assign to the node that has a better fit for the image
+                Vector2Int spaceLeft, spaceRight;
+                bool insertLeft, insertRight;
+                insertLeft = left.TryInsert(insert, padding, out spaceLeft);
+                insertRight = right.TryInsert(insert, padding, out spaceRight);
+                if (insertLeft && insertRight)
+                {
+                    if (spaceLeft.sqrMagnitude < spaceRight.sqrMagnitude)
+                        left.Insert(insert, padding);
+                    else
+                        right.Insert(insert, padding);
+                }
+                else if (insertLeft)
+                    left.Insert(insert, padding);
+                else if (insertRight)
+                    right.Insert(insert, padding);
+                else
+                    return false;
+            }
+            return true;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePackNode.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePacker.cs

@@ -0,0 +1,193 @@
+//#define PACKING_DEBUG
+
+using System;
+using UnityEngine;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace UnityEditor.U2D.Common
+{
+    internal static class ImagePacker
+    {
+        /// <summary>
+        /// Given an array of rects, the method returns an array of rects arranged within outPackedWidth and outPackedHeight
+        /// </summary>
+        /// <param name="rects">Rects to pack</param>
+        /// <param name="padding">Padding between each rect</param>
+        /// <param name="outPackedRects">Rects arranged within outPackedWidth and outPackedHeight</param>
+        /// <param name="outPackedWidth">Width of the packed rects</param>
+        /// <param name="outPackedHeight">Height of the packed rects</param>
+        public static void Pack(RectInt[] rects, int padding, out RectInt[] outPackedRects, out int outPackedWidth, out int outPackedHeight)
+        {
+            var packNode = InternalPack(rects, padding);
+            outPackedWidth = packNode.rect.width;
+            outPackedHeight = packNode.rect.height;
+            var visitor = new CollectPackNodePositionVisitor();
+            packNode.AcceptVisitor(visitor);
+
+            outPackedRects = new RectInt[rects.Length];
+            for (int i = 0; i < rects.Length; ++i)
+                outPackedRects[i] = new RectInt(visitor.positions[i].x + padding, visitor.positions[i].y + padding, rects[i].width, rects[i].height);
+#if PACKING_DEBUG
+            var emptyNodeCollector = new CollectEmptyNodePositionVisitor();
+            packNode.AcceptVisitor(emptyNodeCollector);
+            Array.Resize(ref outPackedRects, rects.Length + emptyNodeCollector.emptyAreas.Count);
+            for (int i = rects.Length; i < outPackedRects.Length; ++i)
+                outPackedRects[i] = emptyNodeCollector.emptyAreas[i - rects.Length];
+#endif
+        }
+
+        /// <summary>
+        /// Packs image buffer into a single buffer. Image buffers are assumed to be 4 bytes per pixel in RGBA format
+        /// </summary>
+        /// <param name="buffers">Image buffers to pack</param>
+        /// <param name="width">Image buffers width</param>
+        /// <param name="height">Image buffers height</param>
+        /// <param name="padding">Padding between each packed image</param>
+        /// <param name="outPackedBuffer">Packed image buffer</param>
+        /// <param name="outPackedBufferWidth">Packed image buffer's width</param>
+        /// <param name="outPackedBufferHeight">Packed iamge buffer's height</param>
+        /// <param name="outPackedRect">Location of each image buffers in the packed buffer</param>
+        /// <param name="outUVTransform">Translation data from image original buffer to packed buffer</param>
+        public static void Pack(NativeArray<Color32>[] buffers, int width, int height, int padding, out NativeArray<Color32> outPackedBuffer, out int outPackedBufferWidth, out int outPackedBufferHeight, out RectInt[] outPackedRect, out Vector2Int[] outUVTransform)
+        {
+            UnityEngine.Profiling.Profiler.BeginSample("Pack");
+            // Determine the area that contains data in the buffer
+            outPackedBuffer = default(NativeArray<Color32>);
+            try
+            {
+                var tightRects = FindTightRectJob.Execute(buffers, width, height);
+                Pack(tightRects, padding, out outPackedRect, out outPackedBufferWidth, out outPackedBufferHeight);
+                outUVTransform = new Vector2Int[tightRects.Length];
+                for (int i = 0; i < outUVTransform.Length; ++i)
+                {
+                    outUVTransform[i] = new Vector2Int(outPackedRect[i].x - tightRects[i].x, outPackedRect[i].y - tightRects[i].y);
+                }
+                outPackedBuffer = new NativeArray<Color32>(outPackedBufferWidth * outPackedBufferHeight, Allocator.Temp);
+
+                Blit(outPackedBuffer, outPackedRect, outPackedBufferWidth, buffers, tightRects, width, padding);
+            }
+            catch (Exception ex)
+            {
+                if (outPackedBuffer.IsCreated)
+                    outPackedBuffer.Dispose();
+                throw ex;
+            }
+            finally
+            {
+                UnityEngine.Profiling.Profiler.EndSample();
+            }
+        }
+
+        static ImagePackNode InternalPack(RectInt[] rects, int padding)
+        {
+            if (rects == null || rects.Length == 0)
+                return new ImagePackNode() { rect = new RectInt(0, 0, 0, 0)};
+            var sortedRects = new ImagePackRect[rects.Length];
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                sortedRects[i] = new ImagePackRect();
+                sortedRects[i].rect = rects[i];
+                sortedRects[i].index = i;
+            }
+            Array.Sort<ImagePackRect>(sortedRects);
+            var root = new ImagePackNode();
+            root.rect = new RectInt(0, 0, (int)NextPowerOfTwo((ulong)rects[0].width), (int)NextPowerOfTwo((ulong)rects[0].height));
+
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                if (!root.Insert(sortedRects[i], padding)) // we can't fit
+                {
+                    int newWidth = root.rect.width , newHeight = root.rect.height;
+                    if (root.rect.width < root.rect.height)
+                        newWidth = (int)NextPowerOfTwo((ulong)root.rect.width + 1);
+                    else
+                        newHeight = (int)NextPowerOfTwo((ulong)root.rect.height + 1);
+                    // Reset all packing and try again
+                    root = new ImagePackNode();
+                    root.rect = new RectInt(0, 0, newWidth, newHeight);
+                    i = -1;
+                }
+            }
+            return root;
+        }
+
+        public static unsafe void Blit(NativeArray<Color32> buffer, RectInt[] blitToArea, int bufferbytesPerRow, NativeArray<Color32>[] originalBuffer, RectInt[] blitFromArea, int bytesPerRow, int padding)
+        {
+            UnityEngine.Profiling.Profiler.BeginSample("Blit");
+
+            var c = (Color32*)buffer.GetUnsafePtr();
+            for (int bufferIndex = 0; bufferIndex < blitToArea.Length && bufferIndex < originalBuffer.Length && bufferIndex < blitFromArea.Length; ++bufferIndex)
+            {
+                var b = (Color32*)originalBuffer[bufferIndex].GetUnsafeReadOnlyPtr();
+                var rectFrom = blitFromArea[bufferIndex];
+                var rectTo = blitToArea[bufferIndex];
+                for (int i = 0; i < rectFrom.height; ++i)
+                {
+                    for (int j = 0; j < rectFrom.width; ++j)
+                    {
+                        Color32 cc = b[(rectFrom.y + i) * bytesPerRow + rectFrom.x + j];
+                        c[((rectTo.y + i) * bufferbytesPerRow) + rectTo.x + j] = cc;
+                    }
+                }
+            }
+
+#if PACKING_DEBUG
+            var emptyColors = new Color32[]
+            {
+                new Color32((byte)255, (byte)0, (byte)0, (byte)255),
+                new Color32((byte)255, (byte)255, (byte)0, (byte)255),
+                new Color32((byte)255, (byte)0, (byte)255, (byte)255),
+                new Color32((byte)255, (byte)255, (byte)255, (byte)255),
+                new Color32((byte)0, (byte)255, (byte)0, (byte)255),
+                new Color32((byte)0, (byte)0, (byte)255, (byte)255)
+            };
+
+            for (int k = originalBuffer.Length; k < blitToArea.Length; ++k)
+            {
+                var rectFrom = blitToArea[k];
+                for (int i = 0; i < rectFrom.height; ++i)
+                {
+                    for (int j = 0; j < rectFrom.width; ++j)
+                    {
+                        c[((rectFrom.y + i) * bufferbytesPerRow) + rectFrom.x + j] =
+                            emptyColors[k % emptyColors.Length];
+                    }
+                }
+            }
+#endif
+            UnityEngine.Profiling.Profiler.EndSample();
+        }
+
+        internal static ulong NextPowerOfTwo(ulong v)
+        {
+            v -= 1;
+            v |= v >> 16;
+            v |= v >> 8;
+            v |= v >> 4;
+            v |= v >> 2;
+            v |= v >> 1;
+            return v + 1;
+        }
+
+        internal class ImagePackRect : IComparable<ImagePackRect>
+        {
+            public RectInt rect;
+            public int index;
+
+            public int CompareTo(ImagePackRect obj)
+            {
+                var lhsArea = rect.width * rect.height;
+                var rhsArea = obj.rect.width * obj.rect.height;
+                if (lhsArea > rhsArea)
+                    return -1;
+                if (lhsArea < rhsArea)
+                    return 1;
+                if (index < obj.index)
+                    return -1;
+
+                return 1;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePacker.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePackerDebugEditor.cs

@@ -0,0 +1,300 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.U2D.Sprites;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.UIElements;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.U2D.Common
+{
+    internal class ImagePackerDebugEditor : EditorWindow
+    {
+        [MenuItem("internal:Window/2D/Common/Image Packer Debug Editor")]
+        static void Launch()
+        {
+            var window = EditorWindow.GetWindow<ImagePackerDebugEditor>();
+            var pos = window.position;
+            pos.height = pos.width = 400;
+            window.position = pos;
+            window.Show();
+        }
+
+        ReorderableList m_ReorderableList;
+        ImagePacker.ImagePackRect[] m_PackingRect = null;
+        List<RectInt> m_PackRects = new List<RectInt>();
+        RectInt[] m_PackResult = null;
+        SpriteRect[] m_SpriteRects = null;
+        Texture2D m_Texture;
+        int m_TextureActualWidth = 0;
+        int m_TextureActualHeight = 0;
+        int m_PackWidth = 0;
+        int m_PackHeight = 0;
+        int m_Padding = 0;
+        Vector2 m_ConfigScroll = Vector2.zero;
+        float m_Zoom = 1;
+        IMGUIContainer m_PackArea;
+        int m_PackStep = -1;
+        protected const float k_MinZoomPercentage = 0.9f;
+        protected const float k_WheelZoomSpeed = 0.03f;
+        protected const float k_MouseZoomSpeed = 0.005f;
+
+        void OnEnable()
+        {
+            var visualContainer = new VisualElement()
+            {
+                name = "Container",
+                style =
+                {
+                    flexGrow = 1,
+                    flexDirection = FlexDirection.Row
+                }
+            };
+            this.rootVisualElement.Add(visualContainer);
+
+            var imgui = new IMGUIContainer(OnConfigGUI)
+            {
+                name = "Config",
+                style =
+                {
+                    width = 300
+                }
+            };
+
+            visualContainer.Add(imgui);
+
+            m_PackArea = new IMGUIContainer(OnImagePackerGUI)
+            {
+                name = "ImagePacker",
+                style =
+                {
+                    flexGrow = 1,
+                }
+            };
+            visualContainer.Add(m_PackArea);
+            SetupConfigGUI();
+        }
+
+        void SetupConfigGUI()
+        {
+            m_ReorderableList = new ReorderableList(m_PackRects, typeof(RectInt), false, false, true, true);
+            m_ReorderableList.elementHeightCallback = (int index) =>
+                {
+                    return EditorGUIUtility.singleLineHeight * 2 + 6;
+                };
+            m_ReorderableList.drawElementCallback = DrawListElement;
+
+            m_ReorderableList.onAddCallback = (list) =>
+                {
+                    m_PackRects.Add(new RectInt());
+                };
+            m_ReorderableList.onRemoveCallback = (list) =>
+                {
+                    m_PackRects.RemoveAt(list.index);
+                };
+        }
+
+        void DrawListElement(Rect rect, int index, bool isactive, bool isfocused)
+        {
+            var rectInt = m_PackRects[index];
+            var name = m_SpriteRects == null || index >= m_SpriteRects.Length ? index.ToString() : m_SpriteRects[index].
+                name;
+            rectInt.size = EditorGUI.Vector2IntField(rect, name, rectInt.size);
+            m_PackRects[index] = rectInt;
+        }
+
+        void OnConfigGUI()
+        {
+            EditorGUILayout.BeginVertical();
+            m_ConfigScroll = EditorGUILayout.BeginScrollView(m_ConfigScroll);
+            m_ReorderableList.DoLayoutList();
+            EditorGUILayout.EndScrollView();
+            GUILayout.FlexibleSpace();
+
+            m_PackStep = EditorGUILayout.IntSlider("Step", m_PackStep, 0, m_PackRects.Count);
+            EditorGUI.BeginChangeCheck();
+            m_Texture = EditorGUILayout.ObjectField(new GUIContent("Texture"), (Object)m_Texture, typeof(Texture2D), false) as Texture2D;
+            if (EditorGUI.EndChangeCheck())
+                UpdateSpriteRect();
+            m_Padding = EditorGUILayout.IntField("Padding", m_Padding);
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("<<"))
+            {
+                m_PackStep = m_PackStep <= 0 ? 0 : m_PackStep - 1;
+                Pack();
+            }
+            if (GUILayout.Button("Pack"))
+                Pack();
+            if (GUILayout.Button(">>"))
+            {
+                m_PackStep = m_PackStep > m_PackRects.Count ? m_PackRects.Count : m_PackStep + 1;
+                Pack();
+            }
+            if (GUILayout.Button("Clear"))
+            {
+                m_PackRects.Clear();
+                m_Texture = null;
+                m_PackingRect = null;
+                m_PackResult = null;
+                m_SpriteRects = null;
+            }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+        }
+
+        void UpdateSpriteRect()
+        {
+            var dataProvider = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(m_Texture)) as ISpriteEditorDataProvider;
+            if (dataProvider == null)
+                return;
+            dataProvider.InitSpriteEditorDataProvider();
+            dataProvider.GetDataProvider<ITextureDataProvider>().GetTextureActualWidthAndHeight(out m_TextureActualWidth, out m_TextureActualHeight);
+            m_SpriteRects = dataProvider.GetDataProvider<ISpriteEditorDataProvider>().GetSpriteRects();
+            m_PackRects.Clear();
+            m_PackRects.AddRange(m_SpriteRects.Select(x => new RectInt((int)x.rect.x, (int)x.rect.y, (int)x.rect.width, (int)x.rect.height)));
+            m_PackResult = null;
+            m_PackStep = m_PackRects.Count;
+        }
+
+        void Pack()
+        {
+            int count = m_PackStep > 0 && m_PackStep < m_PackRects.Count ? m_PackStep : m_PackRects.Count;
+            m_PackingRect = new ImagePacker.ImagePackRect[m_PackRects.Count];
+            for (int i = 0; i < m_PackRects.Count; ++i)
+            {
+                m_PackingRect[i] = new ImagePacker.ImagePackRect()
+                {
+                    rect = m_PackRects[i],
+                    index = i
+                };
+            }
+            Array.Sort(m_PackingRect);
+            ImagePacker.Pack(m_PackingRect.Take(count).Select(x => x.rect).ToArray(), m_Padding, out m_PackResult, out m_PackWidth, out m_PackHeight);
+        }
+
+        void DrawLabel(Rect rect, string label)
+        {
+            rect.position = Handles.matrix.MultiplyPoint(rect.position);
+            GUI.Label(rect, label);
+        }
+
+        void OnImagePackerGUI()
+        {
+            if (m_PackResult == null)
+                return;
+            HandleZoom();
+            var oldMatrix = Handles.matrix;
+            SetupHandlesMatrix();
+            Handles.DrawSolidRectangleWithOutline(new Rect(0, 0, m_PackWidth, m_PackHeight), Color.gray, Color.black);
+            DrawLabel(new Rect(0, 0, m_PackWidth, m_PackHeight), m_PackWidth + "x" + m_PackHeight);
+
+            int index = 0;
+
+            foreach (var rect in m_PackResult)
+            {
+                Handles.DrawSolidRectangleWithOutline(new Rect(rect.x, rect.y, rect.width, rect.height), Color.white, Color.black);
+                var rect1 = new Rect(rect.x, rect.y + rect.height * 0.5f, rect.width, EditorGUIUtility.singleLineHeight);
+                DrawLabel(rect1, m_PackingRect[index].index.ToString());
+                ++index;
+            }
+
+            index = 0;
+            if (m_Texture != null && m_SpriteRects != null)
+            {
+                var material = new Material(Shader.Find("Sprites/Default"));
+                material.mainTexture = m_Texture;
+                material.SetPass(0);
+
+                int mouseOverIndex = -1;
+                GL.PushMatrix();
+                GL.LoadIdentity();
+                GL.MultMatrix(GUI.matrix * Handles.matrix);
+                GL.Begin(GL.QUADS);
+                for (int i = 0; i < m_PackResult.Length; ++i)
+                {
+                    index = m_PackingRect[i].index;
+                    if (index >= m_SpriteRects.Length)
+                        continue;
+                    var rect = m_PackResult[i];
+                    GL.TexCoord(new Vector3(m_SpriteRects[index].rect.x / m_TextureActualWidth, m_SpriteRects[index].rect.y / m_TextureActualHeight, 0));
+                    GL.Vertex(new Vector3(rect.x, rect.y, 0));
+                    GL.TexCoord(new Vector3(m_SpriteRects[index].rect.xMax / m_TextureActualWidth, m_SpriteRects[index].rect.y / m_TextureActualHeight, 0));
+                    GL.Vertex(new Vector3(rect.x + rect.width, rect.y, 0));
+                    GL.TexCoord(new Vector3(m_SpriteRects[index].rect.xMax / m_TextureActualWidth, m_SpriteRects[index].rect.yMax / m_TextureActualHeight, 0));
+                    GL.Vertex(new Vector3(rect.x + rect.width, rect.y + rect.height, 0));
+                    GL.TexCoord(new Vector3(m_SpriteRects[index].rect.x / m_TextureActualWidth, m_SpriteRects[index].rect.yMax / m_TextureActualHeight, 0));
+                    GL.Vertex(new Vector3(rect.x, rect.y + rect.height, 0));
+                    var m = Handles.matrix.inverse.MultiplyPoint(Event.current.mousePosition);
+                    if (rect.Contains(new Vector2Int((int)m.x, (int)m.y)))
+                    {
+                        mouseOverIndex = index;
+                    }
+                    ++index;
+                }
+
+                GL.End();
+                GL.PopMatrix();
+                if (mouseOverIndex >= 0)
+                {
+                    var text = new GUIContent(m_SpriteRects[mouseOverIndex].name + " " + index);
+                    var length = EditorStyles.textArea.CalcSize(text);
+                    var rect1 = new Rect(m_PackResult[mouseOverIndex].x, m_PackResult[mouseOverIndex].y + m_PackResult[mouseOverIndex].height * 0.5f, length.x, length.y);
+                    rect1.position = Handles.matrix.MultiplyPoint(rect1.position);
+                    if (Event.current.type == EventType.Repaint)
+                        EditorStyles.textArea.Draw(rect1, text, false, false, false, false);
+                }
+            }
+
+            Handles.matrix = oldMatrix;
+        }
+
+        void SetupHandlesMatrix()
+        {
+            Vector3 handlesPos = new Vector3(0, m_PackHeight * m_Zoom, 0f);
+            Vector3 handlesScale = new Vector3(m_Zoom, -m_Zoom, 1f);
+            Handles.matrix = Matrix4x4.TRS(handlesPos, Quaternion.identity, handlesScale);
+        }
+
+        protected void HandleZoom()
+        {
+            bool zoomMode = Event.current.alt && Event.current.button == 1;
+            if (zoomMode)
+            {
+                EditorGUIUtility.AddCursorRect(m_PackArea.worldBound, MouseCursor.Zoom);
+            }
+
+            if (
+                ((Event.current.type == EventType.MouseUp || Event.current.type == EventType.MouseDown) && zoomMode) ||
+                ((Event.current.type == EventType.KeyUp || Event.current.type == EventType.KeyDown) && Event.current.keyCode == KeyCode.LeftAlt)
+                )
+            {
+                Repaint();
+            }
+
+            if (Event.current.type == EventType.ScrollWheel || (Event.current.type == EventType.MouseDrag && Event.current.alt && Event.current.button == 1))
+            {
+                float zoomMultiplier = 1f - Event.current.delta.y * (Event.current.type == EventType.ScrollWheel ? k_WheelZoomSpeed : -k_MouseZoomSpeed);
+
+                // Clamp zoom
+                float wantedZoom = m_Zoom * zoomMultiplier;
+
+                float currentZoom = Mathf.Clamp(wantedZoom, GetMinZoom(), 1);
+
+                if (currentZoom != m_Zoom)
+                {
+                    m_Zoom = currentZoom;
+                    Event.current.Use();
+                }
+            }
+        }
+
+        protected float GetMinZoom()
+        {
+            if (m_Texture == null)
+                return 1.0f;
+            return Mathf.Min(m_PackArea.worldBound.width / m_PackWidth, m_PackArea.worldBound.height / m_PackHeight, 0.05f) * k_MinZoomPercentage;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/ImagePackerDebugEditor.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/Jobs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/Jobs/FindTightRectJob.cs

@@ -0,0 +1,59 @@
+using System;
+using UnityEngine;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Jobs;
+
+namespace UnityEditor.U2D.Common
+{
+    public struct FindTightRectJob : IJobParallelFor
+    {
+        [ReadOnly]
+        [DeallocateOnJobCompletion]
+        NativeArray<IntPtr> m_Buffers;
+        [ReadOnly]
+        int m_Width;
+        [ReadOnly]
+        int m_Height;
+        NativeArray<RectInt> m_Output;
+
+        public unsafe void Execute(int index)
+        {
+            var rect = new RectInt(m_Width, m_Height, 0, 0);
+            var color = (Color32*)m_Buffers[index].ToPointer();
+            for (int i = 0; i < m_Height; ++i)
+            {
+                for (int j = 0; j < m_Width; ++j)
+                {
+                    if (color->a != 0)
+                    {
+                        rect.x = Mathf.Min(j, rect.x);
+                        rect.y = Mathf.Min(i, rect.y);
+                        rect.width = Mathf.Max(j, rect.width);
+                        rect.height = Mathf.Max(i, rect.height);
+                    }
+                    ++color;
+                }
+            }
+            rect.width = Mathf.Max(0, rect.width - rect.x + 1);
+            rect.height = Mathf.Max(0, rect.height - rect.y + 1);
+            m_Output[index] = rect;
+        }
+
+        public static unsafe RectInt[] Execute(NativeArray<Color32>[] buffers, int width, int height)
+        {
+            var job = new FindTightRectJob();
+            job.m_Buffers = new NativeArray<IntPtr>(buffers.Length, Allocator.TempJob);
+            for (int i = 0; i < buffers.Length; ++i)
+                job.m_Buffers[i] = new IntPtr(buffers[i].GetUnsafeReadOnlyPtr());
+            job.m_Output = new NativeArray<RectInt>(buffers.Length, Allocator.TempJob);
+            job.m_Width = width;
+            job.m_Height = height;
+            // Ensure all jobs are completed before we return since we don't own the buffers
+            job.Schedule(buffers.Length, 1).Complete();
+            var rects = job.m_Output.ToArray();
+            job.m_Output.Dispose();
+            return rects;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/ImagePacker/Jobs/FindTightRectJob.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/AssemblyInfo.cs

@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.2D.Animation.Editor")]
+[assembly: InternalsVisibleTo("Unity.2D.SpriteShape.Editor")]
+[assembly: InternalsVisibleTo("Unity.2D.SpriteShape.EditorTests")]
+[assembly: InternalsVisibleTo("Unity.2D.PsdImporter.Editor")]

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/InternalBridgeDef.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "Unity.InternalAPIEditorBridge.001",
+    "references": [
+        "Unity.2D.Sprite.Editor"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/InternalBridgeDef.asmdef.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/InternalEditorBridge.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Reflection;
+using UnityEditor.ShortcutManagement;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace UnityEditor.U2D.Common
+{
+    internal static class InternalEditorBridge
+    {
+        public static void RenderSortingLayerFields(SerializedProperty order, SerializedProperty layer)
+        {
+            SortingLayerEditorUtility.RenderSortingLayerFields(order, layer);
+        }
+
+        public static void RepaintImmediately(EditorWindow window)
+        {
+            window.RepaintImmediately();
+        }
+
+        public static ISpriteEditorDataProvider GetISpriteEditorDataProviderFromPath(string importedAsset)
+        {
+            return AssetImporter.GetAtPath(importedAsset) as ISpriteEditorDataProvider;
+        }
+
+        public static void GenerateOutline(Texture2D texture, Rect rect, float detail, byte alphaTolerance, bool holeDetection, out Vector2[][] paths)
+        {
+            UnityEditor.Sprites.SpriteUtility.GenerateOutline(texture, rect, detail, alphaTolerance, holeDetection, out paths);
+        }
+
+        public static bool DoesHardwareSupportsFullNPOT()
+        {
+            return ShaderUtil.hardwareSupportsFullNPOT;
+        }
+
+        public static Texture2D CreateTemporaryDuplicate(Texture2D tex, int width, int height)
+        {
+            return UnityEditor.SpriteUtility.CreateTemporaryDuplicate(tex, width, height);
+        }
+
+        public static void ShowSpriteEditorWindow()
+        {
+            SpriteUtilityWindow.ShowSpriteEditorWindow();
+        }
+
+        public static void ApplyWireMaterial()
+        {
+            HandleUtility.ApplyWireMaterial();
+        }
+
+        public static void ResetSpriteEditorView(ISpriteEditor spriteEditor)
+        {
+            if (spriteEditor != null)
+            {
+                Type t = spriteEditor.GetType();
+                var zoom = t.GetField("m_Zoom", BindingFlags.Instance | BindingFlags.NonPublic);
+                if (zoom != null)
+                {
+                    zoom.SetValue(spriteEditor, -1);
+                }
+
+                var scrollPosition = t.GetField("m_ScrollPosition", BindingFlags.Instance | BindingFlags.NonPublic);
+                if (scrollPosition != null)
+                {
+                    scrollPosition.SetValue(spriteEditor, new Vector2());
+                }
+            }
+        }
+
+        public class ShortcutContext : IShortcutToolContext
+        {
+            public Func<bool> isActive;
+            public bool active
+            {
+                get
+                {
+                    if (isActive != null)
+                        return isActive();
+                    return true;
+                }
+            }
+            public object context { get; set; }
+        }
+
+        public static void RegisterShortcutContext(ShortcutContext context)
+        {
+            ShortcutIntegration.instance.contextManager.RegisterToolContext(context);
+        }
+
+        public static void UnregisterShortcutContext(ShortcutContext context)
+        {
+            ShortcutIntegration.instance.contextManager.DeregisterToolContext(context);
+        }
+
+        public static void AddEditorApplicationProjectLoadedCallback(UnityAction callback)
+        {
+            EditorApplication.projectWasLoaded += callback;
+        }
+
+        public static void RemoveEditorApplicationProjectLoadedCallback(UnityAction callback)
+        {
+            EditorApplication.projectWasLoaded -= callback;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/InternalBridge/InternalEditorBridge.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/TextureGenerator.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/TextureGenerator/TextureGeneratorHelper.cs

@@ -0,0 +1,594 @@
+using System;
+using Unity.Collections;
+using UnityEditor.Experimental.AssetImporters;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Common
+{
+    internal interface ITextureSettings
+    {
+        void FillTextureGenerationSettings(ref TextureGenerationSettings settings);
+    }
+
+
+    [Serializable]
+    internal class TextureSettings : ITextureSettings
+    {
+        [SerializeField]
+        bool m_ColorTexture;
+        [SerializeField]
+        bool m_Readable;
+        [SerializeField]
+        TextureImporterNPOTScale m_NPOTScale;
+        [SerializeField]
+        FilterMode m_FilterMode;
+        [SerializeField]
+        int m_Aniso;
+        [SerializeField]
+        bool m_EnablePostProcessor;
+        [SerializeField]
+        SecondarySpriteTexture[] m_SecondaryTextures;
+
+        public TextureSettings()
+        {
+            colorTexture = true;
+            readable = false;
+            npotScale = TextureImporterNPOTScale.None;
+            filterMode = FilterMode.Bilinear;
+            aniso = 1;
+        }
+
+        public TextureSettings(string assetPath, bool enablePostProcessor, bool colorTexture, bool readable, TextureImporterNPOTScale npotScale, FilterMode filterMode, int aniso, bool sourceContainsAlpha, bool sourceWasHDR)
+        {
+            this.assetPath = assetPath;
+            this.enablePostProcessor = enablePostProcessor;
+            this.colorTexture = colorTexture;
+            this.readable = readable;
+            this.npotScale = npotScale;
+            this.filterMode = filterMode;
+            this.aniso = aniso;
+            this.containsAlpha = sourceContainsAlpha;
+            this.hdr = sourceWasHDR;
+        }
+
+        public bool colorTexture { get { return m_ColorTexture; } set { m_ColorTexture = value; } } //sRGBTexture
+        public bool readable { get { return m_Readable; } set { m_Readable = value; } }
+        public TextureImporterNPOTScale npotScale { get { return m_NPOTScale; } set { m_NPOTScale = value; } }
+        public FilterMode filterMode { get { return m_FilterMode; } set { m_FilterMode = value; } }
+        public int aniso
+        {
+            get { return m_Aniso; }
+            set { m_Aniso = value; }
+        }
+        public bool enablePostProcessor
+        {
+            get { return m_EnablePostProcessor; }
+            set { m_EnablePostProcessor = value; }
+        }
+
+        public string assetPath { get; set; }
+        public bool containsAlpha { get; set; }
+        public bool hdr { get; set; }
+
+        public SecondarySpriteTexture[] secondaryTextures { get { return m_SecondaryTextures;} set { m_SecondaryTextures = value; } }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.sRGBTexture = colorTexture;
+            settings.textureImporterSettings.readable = readable;
+            settings.textureImporterSettings.npotScale = npotScale;
+            settings.textureImporterSettings.filterMode = filterMode;
+            settings.textureImporterSettings.aniso = aniso;
+            settings.assetPath = assetPath;
+            settings.enablePostProcessor = enablePostProcessor;
+            settings.sourceTextureInformation.containsAlpha = containsAlpha;
+            settings.sourceTextureInformation.hdr = hdr;
+            settings.secondarySpriteTextures = secondaryTextures;
+        }
+    }
+
+    [Serializable]
+    internal class TextureSpriteSettings : ITextureSettings
+    {
+        [SerializeField]
+        string m_PackingTag;
+        public string packingTag
+        {
+            get { return m_PackingTag; }
+            set { m_PackingTag = value; }
+        }
+
+        [SerializeField]
+        float m_PixelsPerUnit;
+        public float pixelsPerUnit
+        {
+            get { return m_PixelsPerUnit; }
+            set { m_PixelsPerUnit = value; }
+        }
+
+        [SerializeField]
+        SpriteMeshType m_MeshType;
+        public SpriteMeshType meshType
+        {
+            get { return m_MeshType; }
+            set { m_MeshType = value; }
+        }
+
+        [SerializeField]
+        uint m_ExtrudeEdges;
+        public uint extrudeEdges
+        {
+            get { return m_ExtrudeEdges; }
+            set { m_ExtrudeEdges = value; }
+        }
+
+        public bool qualifyForPacking { get; set; }
+        public SpriteImportData[] spriteSheetData { get; set; }
+
+        public TextureSpriteSettings()
+        {
+            packingTag = "";
+            pixelsPerUnit = 100;
+            meshType = SpriteMeshType.Tight;
+            extrudeEdges = 1;
+        }
+
+        public TextureSpriteSettings(string packingTag, int pixelsPerUnit, SpriteMeshType meshType, uint extrudeEdges, bool qualifyForPacking, SpriteImportData[] spriteSheetData = null)
+        {
+            this.packingTag = packingTag;
+            this.pixelsPerUnit = pixelsPerUnit;
+            this.meshType = meshType;
+            this.extrudeEdges = extrudeEdges;
+            this.qualifyForPacking = qualifyForPacking;
+            this.spriteSheetData = spriteSheetData;
+        }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.spritePixelsPerUnit = pixelsPerUnit;
+            settings.textureImporterSettings.spriteMeshType = meshType;
+            settings.textureImporterSettings.spriteExtrude = extrudeEdges;
+            settings.spritePackingTag = packingTag;
+            settings.qualifyForSpritePacking = qualifyForPacking;
+            settings.spriteImportData = spriteSheetData;
+        }
+    }
+
+    [Serializable]
+    internal class TextureWrapSettings : ITextureSettings
+    {
+        [SerializeField]
+        TextureWrapMode m_WrapMode;
+        [SerializeField]
+        TextureWrapMode m_WrapModeU;
+        [SerializeField]
+        TextureWrapMode m_WrapModeV;
+        [SerializeField]
+        TextureWrapMode m_WrapModeW;
+
+        public TextureWrapSettings()
+        {
+            wrapMode = wrapModeU = wrapModeV = wrapModeW = TextureWrapMode.Repeat;
+        }
+
+        public TextureWrapSettings(TextureWrapMode wrapMpde, TextureWrapMode wrapModeU, TextureWrapMode wrapModeV, TextureWrapMode wrapModeW)
+        {
+            this.wrapMode = wrapMode;
+            this.wrapModeU = wrapModeU;
+            this.wrapModeV = wrapModeV;
+            this.wrapModeW = wrapModeW;
+        }
+
+        public TextureWrapMode wrapMode { get { return m_WrapMode; } set { m_WrapMode = value; } }
+        public TextureWrapMode wrapModeU { get { return m_WrapModeU; } set { m_WrapModeU = value; } }
+        public TextureWrapMode wrapModeV { get { return m_WrapModeV; } set { m_WrapModeV = value; } }
+        public TextureWrapMode wrapModeW { get { return m_WrapModeW; } set { m_WrapModeW = value; } }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.wrapMode = wrapMode;
+            settings.textureImporterSettings.wrapModeU = wrapModeU;
+            settings.textureImporterSettings.wrapModeV = wrapModeV;
+            settings.textureImporterSettings.wrapModeW = wrapModeW;
+        }
+    }
+
+    [Serializable]
+    internal class TextureAlphaSettings : ITextureSettings
+    {
+        [SerializeField]
+        float m_AlphaTolerance;
+        public float alphaTolerance
+        {
+            get { return m_AlphaTolerance; }
+            set { m_AlphaTolerance = value; }
+        }
+
+        [SerializeField]
+        TextureImporterAlphaSource m_AlphaSource;
+        public TextureImporterAlphaSource alphaSource
+        {
+            get { return m_AlphaSource; }
+            set { m_AlphaSource = value; }
+        }
+
+        public TextureAlphaSettings()
+        {
+            alphaTolerance = 0.5f;
+            alphaSource = TextureImporterAlphaSource.FromInput;
+        }
+
+        public TextureAlphaSettings(TextureImporterAlphaSource alphaSource, float alphaTolerance)
+        {
+            this.alphaTolerance = alphaTolerance;
+            this.alphaSource = alphaSource;
+        }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.alphaIsTransparency = alphaSource != TextureImporterAlphaSource.None;
+            settings.textureImporterSettings.alphaSource = alphaSource;
+            settings.textureImporterSettings.alphaTestReferenceValue = alphaTolerance;
+        }
+    }
+
+    [Serializable]
+    internal class TextureMipmapSettings : ITextureSettings
+    {
+        [SerializeField]
+        TextureImporterMipFilter m_Filter;
+        public TextureImporterMipFilter filter
+        {
+            get { return m_Filter; }
+            set { m_Filter = value; }
+        }
+
+        [SerializeField]
+        bool m_BorderMipmap;
+        public bool borderMipmap
+        {
+            get { return m_BorderMipmap; }
+            set { m_BorderMipmap = value; }
+        }
+
+        [SerializeField]
+        bool m_Fadeout;
+        public bool fadeout
+        {
+            get { return m_Fadeout; }
+            set { m_Fadeout = value; }
+        }
+
+        [SerializeField]
+        bool m_PreserveCoverage;
+        public bool preserveCoverage
+        {
+            get { return m_PreserveCoverage; }
+            set { m_PreserveCoverage = value; }
+        }
+
+        [SerializeField]
+        int m_FadeDistanceStart;
+        public int fadeDistanceStart
+        {
+            get { return m_FadeDistanceStart; }
+            set { m_FadeDistanceStart = value; }
+        }
+
+        [SerializeField]
+        int m_FadeDistanceEnd;
+        public int fadeDistanceEnd
+        {
+            get { return m_FadeDistanceEnd; }
+            set { m_FadeDistanceEnd = value; }
+        }
+
+        public TextureMipmapSettings()
+        {
+            filter = TextureImporterMipFilter.BoxFilter;
+            borderMipmap = false;
+            fadeout = false;
+            preserveCoverage = false;
+            fadeDistanceStart = 1;
+            fadeDistanceEnd = 3;
+        }
+
+        public TextureMipmapSettings(TextureImporterMipFilter filter, bool borderMipmap, bool fadeout, bool preserveCoverage, int fadeDistanceStart, int fadeDistanceEnd)
+        {
+            this.filter = filter;
+            this.borderMipmap = borderMipmap;
+            this.fadeout = fadeout;
+            this.preserveCoverage = preserveCoverage;
+            this.fadeDistanceStart = fadeDistanceStart;
+            this.fadeDistanceEnd = fadeDistanceEnd;
+        }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.mipmapEnabled = true;
+            settings.textureImporterSettings.mipmapFilter = filter;
+            settings.textureImporterSettings.borderMipmap = borderMipmap;
+            settings.textureImporterSettings.fadeOut = fadeout;
+            settings.textureImporterSettings.mipmapFadeDistanceStart = fadeDistanceStart;
+            settings.textureImporterSettings.mipmapFadeDistanceEnd = fadeDistanceEnd;
+            settings.textureImporterSettings.mipMapsPreserveCoverage = preserveCoverage;
+        }
+    }
+
+    [Serializable]
+    internal class TextureNormalSettings : ITextureSettings
+    {
+        [SerializeField]
+        TextureImporterNormalFilter m_Filter;
+        public TextureImporterNormalFilter filter
+        {
+            get { return m_Filter; }
+            set { m_Filter = value; }
+        }
+
+        [SerializeField]
+        bool m_GenerateFromGrayScale;
+        public bool generateFromGrayScale
+        {
+            get { return m_GenerateFromGrayScale; }
+            set { m_GenerateFromGrayScale = value; }
+        }
+
+        [SerializeField]
+        float m_Bumpiness;
+        public float bumpiness
+        {
+            get { return m_Bumpiness; }
+            set { m_Bumpiness = value; }
+        }
+
+        public TextureNormalSettings()
+        {
+            filter = TextureImporterNormalFilter.Standard;
+            generateFromGrayScale = false;
+            bumpiness = 0.25f;
+        }
+
+        public TextureNormalSettings(TextureImporterNormalFilter filter, bool generateFromGrayScale, float bumpiness)
+        {
+            this.filter = filter;
+            this.generateFromGrayScale = generateFromGrayScale;
+            this.bumpiness = bumpiness;
+        }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.normalMapFilter = filter;
+            settings.textureImporterSettings.convertToNormalMap = generateFromGrayScale;
+            settings.textureImporterSettings.heightmapScale = bumpiness;
+        }
+    }
+
+    // If this is provided, textureType will be cubemap
+    [Serializable]
+    internal class TextureCubemapSettings : ITextureSettings
+    {
+        [SerializeField]
+        TextureImporterCubemapConvolution m_Convolution;
+        public TextureImporterCubemapConvolution convolution
+        {
+            get { return m_Convolution; }
+            set { m_Convolution = value; }
+        }
+
+        [SerializeField]
+        TextureImporterGenerateCubemap m_Mode;
+        public TextureImporterGenerateCubemap mode
+        {
+            get { return m_Mode; }
+            set { m_Mode = value; }
+        }
+
+        [SerializeField]
+        bool m_Seamless;
+        public bool seamless
+        {
+            get { return m_Seamless; }
+            set { m_Seamless = value; }
+        }
+        public TextureCubemapSettings()
+        {
+            convolution = TextureImporterCubemapConvolution.None;
+            mode = TextureImporterGenerateCubemap.AutoCubemap;
+            seamless = false;
+        }
+
+        public TextureCubemapSettings(TextureImporterCubemapConvolution convolution, TextureImporterGenerateCubemap mode, bool seamless)
+        {
+            this.convolution = convolution;
+            this.mode = mode;
+            this.seamless = seamless;
+        }
+
+        void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
+        {
+            settings.textureImporterSettings.textureShape = TextureImporterShape.TextureCube;
+            settings.textureImporterSettings.cubemapConvolution = convolution;
+            settings.textureImporterSettings.generateCubemap = mode;
+            settings.textureImporterSettings.seamlessCubemap = seamless;
+        }
+    }
+
+    internal static class TextureGeneratorHelper
+    {
+        public static TextureGenerationOutput GenerateTextureSprite(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureSpriteSettings spriteSettings, TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            if (alphaSettings == null)
+                alphaSettings = new TextureAlphaSettings(TextureImporterAlphaSource.FromInput, 0.5f);
+            if (wrapSettings == null)
+                wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
+
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Sprite, platformSettings, settings, spriteSettings, alphaSettings, mipmapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateLightmap(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            settings.colorTexture = true;
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Lightmap, platformSettings, settings, mipmapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateCookie(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Cookie, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateNormalMap(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureNormalSettings normalSettings, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            settings.colorTexture = false;
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.NormalMap, platformSettings, settings, normalSettings, mipmapSettings, cubemapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateTextureGUI(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            settings.colorTexture = false;
+            if (wrapSettings == null)
+                wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.GUI, platformSettings, settings, alphaSettings, mipmapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateTextureSingleChannel(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            settings.colorTexture = false;
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.SingleChannel, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateTextureCursor(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            if (alphaSettings == null)
+                alphaSettings = new TextureAlphaSettings(TextureImporterAlphaSource.FromInput, 0.5f);
+            if (wrapSettings == null)
+                wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
+
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Cursor, platformSettings, settings, alphaSettings, mipmapSettings, wrapSettings);
+        }
+
+        public static TextureGenerationOutput GenerateTextureDefault(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
+            TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
+        {
+            if (mipmapSettings == null)
+                mipmapSettings = new TextureMipmapSettings(TextureImporterMipFilter.BoxFilter, false, false, false, 1, 3);
+
+            return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Default, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
+        }
+
+        static TextureGenerationOutput GenerateTexture(NativeArray<Color32> imageBuffer, int imageBufferWidth, int imageBufferHeight, TextureImporterType type, TextureImporterPlatformSettings platformSettings, params ITextureSettings[] otherSettings)
+        {
+            var textureGenerationSettings = new TextureGenerationSettings();
+            textureGenerationSettings.platformSettings = platformSettings;
+
+            textureGenerationSettings.sourceTextureInformation = new SourceTextureInformation();
+            textureGenerationSettings.sourceTextureInformation.height = imageBufferHeight;
+            textureGenerationSettings.sourceTextureInformation.width = imageBufferWidth;
+
+            textureGenerationSettings.textureImporterSettings = new TextureImporterSettings();
+            textureGenerationSettings.textureImporterSettings.textureType = type;
+            textureGenerationSettings.textureImporterSettings.textureShape = TextureImporterShape.Texture2D;
+
+            textureGenerationSettings.textureImporterSettings.alphaIsTransparency = false;
+            textureGenerationSettings.textureImporterSettings.convertToNormalMap = false;
+            textureGenerationSettings.textureImporterSettings.mipmapEnabled = false;
+            textureGenerationSettings.textureImporterSettings.sRGBTexture = true;
+            textureGenerationSettings.textureImporterSettings.readable = false;
+            textureGenerationSettings.textureImporterSettings.fadeOut = false;
+            textureGenerationSettings.textureImporterSettings.wrapMode = TextureWrapMode.Repeat;
+            textureGenerationSettings.textureImporterSettings.wrapModeU = TextureWrapMode.Repeat;
+            textureGenerationSettings.textureImporterSettings.wrapModeV = TextureWrapMode.Repeat;
+            textureGenerationSettings.textureImporterSettings.wrapModeW = TextureWrapMode.Repeat;
+
+            foreach (var otherSetting in otherSettings)
+            {
+                if (otherSetting != null)
+                    otherSetting.FillTextureGenerationSettings(ref textureGenerationSettings);
+            }
+            return TextureGenerator.GenerateTexture(textureGenerationSettings, imageBuffer);
+        }
+
+        static public TextureSettings ExtractTextureSettings(this TextureImporterSettings tis)
+        {
+            var ts = new TextureSettings();
+            ts.colorTexture = tis.sRGBTexture;
+            ts.readable = tis.readable;
+            ts.npotScale = tis.npotScale;
+            ts.filterMode = tis.filterMode;
+            ts.aniso = tis.aniso;
+            return ts;
+        }
+
+        static public TextureSpriteSettings ExtractTextureSpriteSettings(this TextureImporterSettings tis)
+        {
+            var ts = new TextureSpriteSettings();
+            ts.pixelsPerUnit = tis.spritePixelsPerUnit;
+            ts.meshType = tis.spriteMeshType;
+            ts.extrudeEdges = tis.spriteExtrude;
+            return ts;
+        }
+
+        static public TextureWrapSettings ExtractTextureWrapSettings(this TextureImporterSettings tis)
+        {
+            var ts = new TextureWrapSettings();
+            ts.wrapMode = tis.wrapMode;
+            ts.wrapModeU = tis.wrapModeU;
+            ts.wrapModeV = tis.wrapModeV;
+            ts.wrapModeW = tis.wrapModeW;
+            return ts;
+        }
+
+        static public TextureAlphaSettings ExtractTextureAlphaSettings(this TextureImporterSettings settings)
+        {
+            if (settings.alphaIsTransparency == false)
+                return null;
+
+            var ts = new TextureAlphaSettings();
+            ts.alphaSource = settings.alphaSource;
+            ts.alphaTolerance = settings.alphaTestReferenceValue;
+            return ts;
+        }
+
+        static public TextureMipmapSettings ExtractTextureMipmapSettings(this TextureImporterSettings settings)
+        {
+            if (!settings.mipmapEnabled)
+                return null;
+
+            var ts = new TextureMipmapSettings();
+            ts.filter = settings.mipmapFilter;
+            ts.borderMipmap = settings.borderMipmap;
+            ts.fadeout = settings.fadeOut;
+            ts.fadeDistanceStart = settings.mipmapFadeDistanceStart;
+            ts.fadeDistanceEnd = settings.mipmapFadeDistanceEnd;
+            ts.preserveCoverage = settings.mipMapsPreserveCoverage;
+            return ts;
+        }
+
+        static public TextureNormalSettings ExtractTextureNormalSettings(this TextureImporterSettings settings)
+        {
+            var ts = new TextureNormalSettings();
+            ts.filter = settings.normalMapFilter;
+            ts.generateFromGrayScale = settings.convertToNormalMap;
+            ts.bumpiness = settings.heightmapScale;
+            return ts;
+        }
+
+        static public TextureCubemapSettings ExtractTextureCubemapSettings(this TextureImporterSettings settings)
+        {
+            if (settings.textureShape != TextureImporterShape.TextureCube)
+                return null;
+            var ts = new TextureCubemapSettings();
+            ts.convolution = settings.cubemapConvolution;
+            ts.mode = settings.generateCubemap;
+            ts.seamless = settings.seamlessCubemap;
+            return ts;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/TextureGenerator/TextureGeneratorHelper.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/Unity.2D.Common.Editor.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "Unity.2D.Common.Editor",
+    "references": [
+        "Unity.2D.Common.Runtime",
+        "Unity.2D.Sprite.Editor"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Editor/Unity.2D.Common.Editor.asmdef.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/LICENSE.md

@@ -0,0 +1,29 @@
+com.unity.2d.common copyright © 2020 Unity Technologies ApS
+
+Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
+
+1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
+
+1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
+
+1. *Ownership & Grant Back to You*. 
+
+    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
+
+    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
+
+    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
+
+1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
+
+1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
+
+1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
+
+1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+
+1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+
+1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.

Library/PackageCache/com.unity.2d.common@2.1.0/LICENSE.md.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/README.md

@@ -0,0 +1,4 @@
+2D Shared Code
+
+- Triangle.net - a Unity friendly version of the triangle.net used to generate geometry.
+- ImagePacker - fits  a list of textures or rects into a bigger rect. 

Library/PackageCache/com.unity.2d.common@2.1.0/README.md.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/AssemblyInfo.cs

@@ -0,0 +1 @@
+using System.Runtime.CompilerServices;

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/AssemblyInfo.cs

@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.2D.Animation.Runtime")]
+[assembly: InternalsVisibleTo("Unity.2D.Animation.Editor")]
+[assembly: InternalsVisibleTo("Unity.2D.IK.Editor")]

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/InternalBridgeDef.asmdef

@@ -0,0 +1,7 @@
+{
+    "name": "Unity.InternalAPIEngineBridge.001",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": []
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/InternalBridgeDef.asmdef.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/InternalEngineBridge.cs

@@ -0,0 +1,58 @@
+using UnityEngine.UIElements;
+using Unity.Collections;
+
+namespace UnityEngine.U2D.Common
+{
+    internal static class InternalEngineBridge
+    {
+        public static void SetLocalAABB(SpriteRenderer spriteRenderer, Bounds aabb)
+        {
+            spriteRenderer.SetLocalAABB(aabb);
+        }
+
+        public static void SetDeformableBuffer(SpriteRenderer spriteRenderer, NativeArray<byte> src)
+        {
+            spriteRenderer.SetDeformableBuffer(src);
+        }
+
+        public static Vector2 GUIUnclip(Vector2 v)
+        {
+            return GUIClip.Unclip(v);
+        }
+
+        public static Rect GetGUIClipTopMostRect()
+        {
+            return GUIClip.topmostRect;
+        }
+
+        public static Rect GetGUIClipTopRect()
+        {
+            return GUIClip.GetTopRect();
+        }
+
+#if UNITY_EDITOR
+        public static void SetLocalEulerHint(Transform t)
+        {
+            t.SetLocalEulerHint(t.GetLocalEulerAngles(t.rotationOrder));
+        }
+
+        public static bool IsChecked(this VisualElement element)
+        {
+            return (element.pseudoStates & PseudoStates.Checked) == PseudoStates.Checked;
+        }
+
+        public static void SetChecked(this VisualElement element, bool isChecked)
+        {
+            if (isChecked)
+            {
+                element.pseudoStates |= PseudoStates.Checked;
+            }
+            else
+            {
+                element.pseudoStates &= ~PseudoStates.Checked;
+            }
+        }
+
+#endif
+    }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/InternalBridge/InternalEngineBridge.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/Unity.2D.Common.Runtime.asmdef

@@ -0,0 +1,6 @@
+{
+    "name": "Unity.2D.Common.Runtime",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": []
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Runtime/Unity.2D.Common.Runtime.asmdef.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Tests.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Tests/Editor.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Tests/Editor/PlaceholderTests.cs

@@ -0,0 +1,16 @@
+using NUnit.Framework;
+
+
+namespace UnityEditor.Experimental.U2D.Commons.Tests
+{
+    public class Placeholder
+    {
+        [Test]
+        public void PlaceHolderTest()
+        {
+            // Use the Assert class to test conditions.
+            Assert.Pass("This is a placeholder to ensure we have at least one test.");
+        }
+    }
+
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Tests/Editor/PlaceholderTests.cs.meta

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

Library/PackageCache/com.unity.2d.common@2.1.0/Tests/Editor/Unity.2D.Common.EditorTests.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "Unity.2D.Common.EditorTests",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Library/PackageCache/com.unity.2d.common@2.1.0/Tests/Editor/Unity.2D.Common.EditorTests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 03bfc083748b8452197dde3b8ea7fbba
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.2d.common@2.1.0/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "com.unity.2d.common",
+  "displayName": "2D Common",
+  "version": "2.1.0",
+  "unity": "2019.4",
+  "unityRelease": "0a13",
+  "description": "2D Common is a package that contains shared functionalities that are used by most of the other 2D packages.",
+  "keywords": [
+    "2d"
+  ],
+  "category": "2D",
+  "dependencies": {
+    "com.unity.2d.sprite": "1.0.0",
+    "com.unity.modules.uielements": "1.0.0"
+  },
+  "relatedPackages": {
+    "com.unity.2d.common.tests": "2.1.0"
+  },
+  "upmCi": {
+    "footprint": "edc180f0cefe01cc5e8a5f180f68c73e4b688cca"
+  },
+  "repository": {
+    "url": "https://github.cds.internal.unity3d.com/unity/2d.git",
+    "type": "git",
+    "revision": "af64689d11b5d27eeab4dbd14d16b98d0b3e5fc4"
+  }
+}

Library/PackageCache/com.unity.2d.common@2.1.0/package.json.meta

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