testss
This commit is contained in:
64
Library/PackageCache/com.unity.2d.common@5.0.0/CHANGELOG.md
Normal file
64
Library/PackageCache/com.unity.2d.common@5.0.0/CHANGELOG.md
Normal file
@@ -0,0 +1,64 @@
|
||||
# Changelog
|
||||
|
||||
## [5.0.0] - 2021-03-17
|
||||
### Changed
|
||||
- Update version for release
|
||||
|
||||
## [5.0.0-pre.2] - 2021-01-16
|
||||
### Changed
|
||||
- Update license file
|
||||
|
||||
## [5.0.0-pre.1] - 2020-10-30
|
||||
### Changed
|
||||
- Version bump for Unity 2021.1
|
||||
|
||||
## [4.0.3] - 2020-10-15
|
||||
### Fixed
|
||||
- Allow 2D Packages to access internal constant value for asset creation instance id
|
||||
|
||||
## [4.0.2] - 2020-08-31
|
||||
### Fixed
|
||||
- Allow launching Sprite Editor Window to target a specific asset
|
||||
|
||||
## [4.0.1] - 2020-07-07
|
||||
### Fixed
|
||||
- Updated to use non-experimental AssetImporter namespace (case 1254381)
|
||||
|
||||
## [4.0.0] - 2020-05-11
|
||||
### Changed
|
||||
- Version bump for Unity 2020.2
|
||||
|
||||
## [3.0.0] - 2019-11-06
|
||||
### Changed
|
||||
- Update version number for Unity 2020.1
|
||||
|
||||
## [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.
|
||||
@@ -0,0 +1,3 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
[assembly: InternalsVisibleTo("Unity.2D.Common.Tests.EditorTests")]
|
||||
[assembly: InternalsVisibleTo("Unity.2D.PsdImporter.Editor")]
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.Persistent);
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")]
|
||||
@@ -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": []
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
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(UnityEngine.Object obj = null)
|
||||
{
|
||||
SpriteUtilityWindow.ShowSpriteEditorWindow(obj);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
public static string GetProjectWindowActiveFolderPath()
|
||||
{
|
||||
return ProjectWindowUtil.GetActiveFolderPath();
|
||||
}
|
||||
|
||||
public static GUIContent GetIconContent<T>() where T : UnityEngine.Object
|
||||
{
|
||||
return EditorGUIUtility.IconContent<T>();
|
||||
}
|
||||
|
||||
public static int GetAssetCreationInstanceID_ForNonExistingAssets()
|
||||
{
|
||||
return ProjectBrowser.kAssetCreationInstanceID_ForNonExistingAssets;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using UnityEditor;
|
||||
using UnityEditor.Build;
|
||||
using System;
|
||||
using UnityEditor.Modules;
|
||||
|
||||
namespace UnityEditor.U2D.Common
|
||||
{
|
||||
|
||||
internal interface ITexturePlatformSettingsDataProvider
|
||||
{
|
||||
bool textureTypeHasMultipleDifferentValues { get; }
|
||||
TextureImporterType textureType { get; }
|
||||
SpriteImportMode spriteImportMode { get; }
|
||||
|
||||
int GetTargetCount();
|
||||
TextureImporterPlatformSettings GetPlatformTextureSettings(int i, string name);
|
||||
bool ShowPresetSettings();
|
||||
bool DoesSourceTextureHaveAlpha(int v);
|
||||
bool IsSourceTextureHDR(int v);
|
||||
void SetPlatformTextureSettings(int i, TextureImporterPlatformSettings platformSettings);
|
||||
void GetImporterSettings(int i, UnityEditor.TextureImporterSettings settings);
|
||||
}
|
||||
|
||||
internal class TexturePlatformSettings : BaseTextureImportPlatformSettings
|
||||
{
|
||||
[SerializeField]
|
||||
TextureImportPlatformSettingsData m_Data = new TextureImportPlatformSettingsData();
|
||||
ITexturePlatformSettingsDataProvider m_DataProvider;
|
||||
Func<BaseTextureImportPlatformSettings> DefaultImportSettings;
|
||||
|
||||
public override TextureImportPlatformSettingsData model
|
||||
{
|
||||
get => m_Data;
|
||||
}
|
||||
|
||||
public TexturePlatformSettings(string name, BuildTarget target, ITexturePlatformSettingsDataProvider inspector, Func<BaseTextureImportPlatformSettings> defaultPlatform) : base(name, target)
|
||||
{
|
||||
m_DataProvider = inspector;
|
||||
DefaultImportSettings = defaultPlatform;
|
||||
Init();
|
||||
}
|
||||
|
||||
|
||||
public override bool textureTypeHasMultipleDifferentValues
|
||||
{
|
||||
get { return m_DataProvider.textureTypeHasMultipleDifferentValues; }
|
||||
}
|
||||
|
||||
public override TextureImporterType textureType
|
||||
{
|
||||
get { return m_DataProvider.textureType; }
|
||||
}
|
||||
|
||||
public override SpriteImportMode spriteImportMode
|
||||
{
|
||||
get { return m_DataProvider.spriteImportMode; }
|
||||
}
|
||||
|
||||
public override int GetTargetCount()
|
||||
{
|
||||
return m_DataProvider.GetTargetCount();
|
||||
}
|
||||
|
||||
public override bool ShowPresetSettings()
|
||||
{
|
||||
return m_DataProvider.ShowPresetSettings();
|
||||
}
|
||||
|
||||
public override TextureImporterSettings GetImporterSettings(int i)
|
||||
{
|
||||
var textureImporterSettings = new TextureImporterSettings();
|
||||
m_DataProvider.GetImporterSettings(i, textureImporterSettings);
|
||||
return textureImporterSettings;
|
||||
}
|
||||
|
||||
public override bool IsSourceTextureHDR(int i)
|
||||
{
|
||||
return m_DataProvider.IsSourceTextureHDR(i);
|
||||
}
|
||||
|
||||
public override bool DoesSourceTextureHaveAlpha(int i)
|
||||
{
|
||||
return m_DataProvider.DoesSourceTextureHaveAlpha(i);
|
||||
}
|
||||
|
||||
public override TextureImporterPlatformSettings GetPlatformTextureSettings(int i, string name)
|
||||
{
|
||||
return m_DataProvider.GetPlatformTextureSettings(i, name);
|
||||
}
|
||||
|
||||
public override BaseTextureImportPlatformSettings GetDefaultImportSettings()
|
||||
{
|
||||
return DefaultImportSettings();
|
||||
}
|
||||
|
||||
public override void SetPlatformTextureSettings(int i, TextureImporterPlatformSettings platformSettings)
|
||||
{
|
||||
platformSettings.name = GetFixedPlatformName(platformSettings.name);
|
||||
m_DataProvider.SetPlatformTextureSettings(i, platformSettings);
|
||||
}
|
||||
|
||||
private string GetFixedPlatformName(string platform)
|
||||
{
|
||||
var targetGroup = BuildPipeline.GetBuildTargetGroupByName(platform);
|
||||
if (targetGroup != BuildTargetGroup.Unknown)
|
||||
return BuildPipeline.GetBuildTargetGroupName(targetGroup);
|
||||
return platform;
|
||||
}
|
||||
}
|
||||
|
||||
internal class TexturePlatformSettingsHelper
|
||||
{
|
||||
[SerializeField]
|
||||
List<TexturePlatformSettings> m_PlatformSettings;
|
||||
ITexturePlatformSettingsDataProvider m_DataProvider;
|
||||
|
||||
public TexturePlatformSettingsHelper(ITexturePlatformSettingsDataProvider dataProvider)
|
||||
{
|
||||
m_DataProvider = dataProvider;
|
||||
BuildPlatform[] validPlatforms = BaseTextureImportPlatformSettings.GetBuildPlayerValidPlatforms();
|
||||
|
||||
m_PlatformSettings = new List<TexturePlatformSettings>();
|
||||
m_PlatformSettings.Add(new TexturePlatformSettings(TextureImporterInspector.s_DefaultPlatformName, BuildTarget.StandaloneWindows, dataProvider, DefaulTextureImportPlatformSettings));
|
||||
|
||||
foreach (BuildPlatform bp in validPlatforms)
|
||||
m_PlatformSettings.Add(new TexturePlatformSettings(bp.name, bp.defaultTarget, dataProvider, DefaulTextureImportPlatformSettings));
|
||||
}
|
||||
|
||||
BaseTextureImportPlatformSettings DefaulTextureImportPlatformSettings()
|
||||
{
|
||||
return m_PlatformSettings[0];
|
||||
}
|
||||
|
||||
public static string defaultPlatformName { get => TextureImporterInspector.s_DefaultPlatformName; }
|
||||
|
||||
public SpriteImportMode spriteImportMode
|
||||
{
|
||||
get { return m_DataProvider.spriteImportMode; }
|
||||
}
|
||||
|
||||
public TextureImporterType textureType
|
||||
{
|
||||
get { return m_DataProvider.textureType; }
|
||||
}
|
||||
|
||||
public bool textureTypeHasMultipleDifferentValues
|
||||
{
|
||||
get { return m_DataProvider.textureTypeHasMultipleDifferentValues; }
|
||||
}
|
||||
|
||||
public void ShowPlatformSpecificSettings()
|
||||
{
|
||||
BaseTextureImportPlatformSettings.ShowPlatformSpecificSettings(m_PlatformSettings.ConvertAll<BaseTextureImportPlatformSettings>(x => x as BaseTextureImportPlatformSettings));
|
||||
SyncPlatformSettings();
|
||||
}
|
||||
|
||||
public bool HasModified()
|
||||
{
|
||||
foreach (var ps in m_PlatformSettings)
|
||||
{
|
||||
if (ps.model.HasChanged())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void SyncPlatformSettings()
|
||||
{
|
||||
foreach (var ps in m_PlatformSettings)
|
||||
ps.Sync();
|
||||
}
|
||||
|
||||
public void Apply()
|
||||
{
|
||||
foreach (var ps in m_PlatformSettings)
|
||||
ps.Apply();
|
||||
}
|
||||
|
||||
public static string GetBuildTargetName(BuildTarget target)
|
||||
{
|
||||
BuildPlatform[] validPlatforms = BaseTextureImportPlatformSettings.GetBuildPlayerValidPlatforms();
|
||||
foreach (var bp in validPlatforms)
|
||||
{
|
||||
if (bp.defaultTarget == target)
|
||||
return bp.name;
|
||||
}
|
||||
return TextureImporter.defaultPlatformName;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,594 @@
|
||||
using System;
|
||||
using Unity.Collections;
|
||||
using UnityEditor.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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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": []
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
com.unity.2d.common copyright © 2020 Unity Technologies ApS
|
||||
|
||||
Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
|
||||
|
||||
Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
|
||||
4
Library/PackageCache/com.unity.2d.common@5.0.0/README.md
Normal file
4
Library/PackageCache/com.unity.2d.common@5.0.0/README.md
Normal file
@@ -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.
|
||||
@@ -0,0 +1 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
@@ -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")]
|
||||
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"name": "Unity.InternalAPIEngineBridge.001",
|
||||
"references": [],
|
||||
"optionalUnityReferences": [],
|
||||
"includePlatforms": [],
|
||||
"excludePlatforms": []
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
using System;
|
||||
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();
|
||||
}
|
||||
|
||||
public static void SetBatchDeformableBufferAndLocalAABBArray(SpriteRenderer[] spriteRenderers, NativeArray<IntPtr> buffers, NativeArray<int> bufferSizes, NativeArray<Bounds> bounds)
|
||||
{
|
||||
SpriteRendererDataAccessExtensions.SetBatchDeformableBufferAndLocalAABBArray(spriteRenderers, buffers, bufferSizes, bounds);
|
||||
}
|
||||
|
||||
#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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"name": "Unity.2D.Common.Runtime",
|
||||
"references": [],
|
||||
"includePlatforms": [],
|
||||
"excludePlatforms": []
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
using NUnit.Framework;
|
||||
|
||||
|
||||
namespace UnityEditor.Experimental.U2D.Commons.Tests
|
||||
{
|
||||
internal 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.");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"name": "Unity.2D.Common.EditorTests",
|
||||
"references": [
|
||||
],
|
||||
"optionalUnityReferences": [
|
||||
"TestAssemblies"
|
||||
],
|
||||
"includePlatforms": [
|
||||
"Editor"
|
||||
],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": false,
|
||||
"overrideReferences": false,
|
||||
"precompiledReferences": [],
|
||||
"autoReferenced": true,
|
||||
"defineConstraints": [
|
||||
"UNITY_INCLUDE_TESTS"
|
||||
],
|
||||
"versionDefines": []
|
||||
}
|
||||
26
Library/PackageCache/com.unity.2d.common@5.0.0/package.json
Normal file
26
Library/PackageCache/com.unity.2d.common@5.0.0/package.json
Normal file
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"name": "com.unity.2d.common",
|
||||
"displayName": "2D Common",
|
||||
"version": "5.0.0",
|
||||
"unity": "2021.1",
|
||||
"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": "5.0.0"
|
||||
},
|
||||
"upmCi": {
|
||||
"footprint": "9bf8b417772b8d4bbb789cb8a4e741c584e5a863"
|
||||
},
|
||||
"repository": {
|
||||
"url": "https://github.cds.internal.unity3d.com/unity/2d.git",
|
||||
"type": "git",
|
||||
"revision": "82ee1598c2f1270bc1081c1f908364e528335bd5"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user