public override void OnModuleActivate()
{
if (m_StyleSelectionStrings == null)
{
m_StyleSelectionStrings = kMLStyle.Select(x => x.name).ToArray();
}
if (m_Material == null)
{
m_Material = new Material(Shader.Find("Sprites/Default"));
}
m_AssetImporter = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>() as AssetImporter;
m_TextureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
if (!int.TryParse(m_AssetImporter.userData, out m_CurrentStyleSelection))
{
m_CurrentStyleSelection = 0;
}
// var tex = m_TextureDataProvider.GetReadableTexture2D();
// if (kMLStyle[m_CurrentStyleSelection].processFunc != null)
// {
// m_ProcessedTexture = new Texture2D(tex.width, tex.height, TextureFormat.ARGB32, false);
// m_ProcessedTexture.SetPixels32(kMLStyle[m_CurrentStyleSelection].processFunc(tex));
// m_ProcessedTexture.Apply();
// }
}
static void GenerateOutline(SpriteCache sprite, ITextureDataProvider textureDataProvider,
out List <Vertex2D> vertices, out List <int> indices, out List <Edge> edges)
{
if (textureDataProvider == null ||
textureDataProvider.texture == null)
{
vertices = new List <Vertex2D>();
indices = new List <int>();
edges = new List <Edge>();
return;
}
const float detail = 0.05f;
const byte alphaTolerance = 200;
var smd = new SpriteMeshData
{
spriteID = new GUID(sprite.id),
frame = sprite.textureRect,
pivot = sprite.pivotNormalized
};
var meshDataController = new SpriteMeshDataController
{
spriteMeshData = smd
};
meshDataController.OutlineFromAlpha(new OutlineGenerator(), textureDataProvider, detail, alphaTolerance);
meshDataController.Triangulate(new Triangulator());
vertices = smd.vertices;
indices = smd.indices;
edges = smd.edges;
}
public override void OnModuleActivate()
{
m_TextureDataProvider = spriteEditorWindow.GetDataProvider <ITextureDataProvider>();
LoadOutline();
GenerateOutlineIfNotExist();
undoSystem.RegisterUndoCallback(UndoRedoPerformed);
shapeEditorDirty = true;
SetupShapeEditor();
spriteEditorWindow.enableMouseMoveEvent = true;
}
public override void OnModuleActivate()
{
this.m_TextureDataProvider = this.spriteEditorWindow.GetDataProvider <ITextureDataProvider>();
this.LoadOutline();
this.GenerateOutlineIfNotExist();
this.undoSystem.RegisterUndoCallback(new Undo.UndoRedoCallback(this.UndoRedoPerformed));
this.shapeEditorDirty = true;
this.SetupShapeEditor();
this.spriteEditorWindow.enableMouseMoveEvent = true;
}
public void GenerateOutline(ITextureDataProvider textureDataProvider, Rect rect, float detail, byte alphaTolerance, bool holeDetection, out Vector2[][] paths)
{
if (alphaTolerance >= 255)
{
throw new ArgumentException("Alpha tolerance should be lower than 255");
}
m_CurrentTexture = textureDataProvider.GetReadableTexture2D();
m_CurrentRect = rect;
m_CurrentAlphaTolerance = alphaTolerance;
InternalEditorBridge.GenerateOutline(textureDataProvider.texture, rect, 1f, alphaTolerance, holeDetection, out paths);
if (paths.Length > 0)
{
ClipPaths(ref paths);
Debug.Assert(paths.Length > 0);
var rectSizeMagnitude = rect.size.magnitude;
var minDistance = Mathf.Max(rectSizeMagnitude / 10f, kMinLinearizeDistance);
var maxDistance = Mathf.Max(rectSizeMagnitude / 100f, kMinLinearizeDistance);
var distance = Mathf.Lerp(minDistance, maxDistance, detail);
for (var pathIndex = 0; pathIndex < paths.Length; ++pathIndex)
{
var pathLength = CalculatePathLength(paths[pathIndex]);
if (pathLength > distance)
{
var newPath = Linearize(new List <Vector2>(paths[pathIndex]), distance);
if (newPath.Count > 3)
{
paths[pathIndex] = newPath.ToArray();
}
SmoothPath(paths[pathIndex], 5, 0.1f, 135f);
}
}
ClipPaths(ref paths);
}
// Merge the Polygons to one (doesn't always succeeds).
var clipper = new Clipper(Clipper.ioPreserveCollinear);
var subj = ToClipper(paths);
var solution = new Paths();
clipper.AddPaths(subj, PolyType.ptSubject, true);
clipper.Execute(ClipType.ctUnion, solution, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
paths = ToVector2(solution);
m_CurrentAlphaTolerance = alphaTolerance;
}
void DisplayMainTexture()
{
ITextureDataProvider textureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
if (textureDataProvider != null && textureDataProvider.previewTexture != null)
{
Texture2D mainTexture = textureDataProvider.previewTexture;
int width = 0, height = 0;
textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
spriteEditor.SetPreviewTexture(mainTexture, width, height);
}
}
public override void OnModuleDeactivate()
{
// Reset to display the main texture.
ITextureDataProvider textureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
if (textureDataProvider != null && textureDataProvider.previewTexture != null)
{
Texture2D mainTexture = textureDataProvider.previewTexture;
int width = 0, height = 0;
textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
spriteEditor.SetPreviewTexture(mainTexture, width, height);
}
}
static float CalculateDefinitionScale(Texture2D texture, ITextureDataProvider dataProvider)
{
float definitionScale = 1;
if (texture != null && dataProvider != null)
{
int actualWidth = 0, actualHeight = 0;
dataProvider.GetTextureActualWidthAndHeight(out actualWidth, out actualHeight);
float definitionScaleW = texture.width / (float)actualWidth;
float definitionScaleH = texture.height / (float)actualHeight;
definitionScale = Mathf.Min(definitionScaleW, definitionScaleH);
}
return(definitionScale);
}
private void Init(Rect buttonRect, SpriteFrameModule sf, ITextureDataProvider dataProvider)
{
if (SpriteEditorMenu.s_Setting == null)
{
SpriteEditorMenu.s_Setting = ScriptableObject.CreateInstance <SpriteEditorMenuSetting>();
}
this.m_SpriteFrameModule = sf;
this.m_TextureDataProvider = dataProvider;
buttonRect = GUIUtility.GUIToScreenRect(buttonRect);
float y = 145f;
Vector2 windowSize = new Vector2(300f, y);
base.ShowAsDropDown(buttonRect, windowSize, null, ShowMode.PopupMenuWithKeyboardFocus);
Undo.undoRedoPerformed = (Undo.UndoRedoCallback)Delegate.Combine(Undo.undoRedoPerformed, new Undo.UndoRedoCallback(this.UndoRedoPerformed));
}
public void RefreshPropertiesCache()
{
this.m_SelectedAssetPath = this.GetSelectionAssetPath();
this.m_SpriteDataProvider = (AssetImporter.GetAtPath(this.m_SelectedAssetPath) as ISpriteEditorDataProvider);
if (this.m_SpriteDataProvider != null)
{
this.m_SpriteDataProvider.InitSpriteEditorDataProvider();
ITextureDataProvider dataProvider = this.m_SpriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (dataProvider != null)
{
int width = 0;
int height = 0;
dataProvider.GetTextureActualWidthAndHeight(out width, out height);
this.m_Texture = ((!(dataProvider.texture == null)) ? new SpriteEditorWindow.PreviewTexture2D(dataProvider.texture, width, height) : null);
}
}
}
public void OutlineFromAlpha(IOutlineGenerator outlineGenerator, ITextureDataProvider textureDataProvider, float outlineDetail, byte alphaTolerance)
{
Debug.Assert(spriteMeshData != null, "Assert failed. Expected: spriteMeshData != null. Actual: spriteMeshData == null");
Debug.Assert(textureDataProvider != null, "Assert failed. Expected: textureDataProvider != null. Actual: textureDataProvider == null");
Debug.Assert(textureDataProvider.texture != null, "Assert failed. Expected: textureDataProvider.texture != null. Actual: textureDataProvider.texture == null");
int width, height;
textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
Vector2 scale = new Vector2(textureDataProvider.texture.width / (float)width, textureDataProvider.texture.height / (float)height);
Vector2 scaleInv = new Vector2(1f / scale.x, 1f / scale.y);
Vector2 rectOffset = spriteMeshData.frame.size * 0.5f;
Rect scaledRect = spriteMeshData.frame;
scaledRect.min = Vector2.Scale(scaledRect.min, scale);
scaledRect.max = Vector2.Scale(scaledRect.max, scale);
spriteMeshData.Clear();
Vector2[][] paths;
outlineGenerator.GenerateOutline(textureDataProvider, scaledRect, outlineDetail, alphaTolerance, false, out paths);
int vertexIndexBase = 0;
for (int i = 0; i < paths.Length; ++i)
{
int numPathVertices = paths[i].Length;
for (int j = 0; j <= numPathVertices; j++)
{
if (j < numPathVertices)
{
spriteMeshData.AddVertex(Vector2.Scale(paths[i][j], scaleInv) + rectOffset, default(BoneWeight));
}
if (j > 0)
{
spriteMeshData.edges.Add(new Edge(vertexIndexBase + j - 1, vertexIndexBase + j % numPathVertices));
}
}
vertexIndexBase += numPathVertices;
}
}
public override void OnModuleDeactivate()
{
// Reset to display the main texture.
ITextureDataProvider textureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
if (textureDataProvider != null && textureDataProvider.previewTexture != null)
{
Texture2D mainTexture = textureDataProvider.previewTexture;
int width = 0, height = 0;
textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
spriteEditor.SetPreviewTexture(mainTexture, width, height);
}
if (spriteEditor.GetMainVisualContainer().Contains(m_SecondaryTextureInspectorContainer))
{
spriteEditor.GetMainVisualContainer().Remove(m_SecondaryTextureInspectorContainer);
}
}
// implements ISpriteEditorModule
public override void OnModuleActivate()
{
spriteImportMode = SpriteUtility.GetSpriteImportMode(spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
m_TextureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_SpriteDataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int width, height;
m_TextureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
textureActualWidth = width;
textureActualHeight = height;
m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
m_RectsCache.spriteRects = m_SpriteDataProvider.GetSpriteRects().ToList();
spriteEditor.spriteRects = m_RectsCache.spriteRects;
if (spriteEditor.selectedSpriteRect != null)
{
spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID);
}
}
public override void OnModuleActivate()
{
this.spriteImportMode = SpriteUtility.GetSpriteImportMode(base.spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
this.m_TextureDataProvider = base.spriteEditor.GetDataProvider <ITextureDataProvider>();
this.m_SpriteDataProvider = base.spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int textureActualWidth;
int textureActualHeight;
this.m_TextureDataProvider.GetTextureActualWidthAndHeight(out textureActualWidth, out textureActualHeight);
this.textureActualWidth = textureActualWidth;
this.textureActualHeight = textureActualHeight;
this.m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
this.m_RectsCache.spriteRects = this.m_SpriteDataProvider.GetSpriteRects().ToList <SpriteRect>();
if (base.spriteEditor.selectedSpriteRect != null)
{
base.spriteEditor.selectedSpriteRect = this.m_RectsCache.spriteRects.FirstOrDefault((SpriteRect x) => x.spriteID == base.spriteEditor.selectedSpriteRect.spriteID);
}
}
public void GenerateOutline(ITextureDataProvider textureDataProvider, Rect rect, float detail, byte alphaTolerance, bool holeDetection, out Vector2[][] paths)
{
if (alphaTolerance >= 255)
{
throw new ArgumentException("Alpha tolerance should be lower than 255");
}
m_CurrentTexture = textureDataProvider.GetReadableTexture2D();
m_CurrentRect = rect;
m_CurrentAlphaTolerance = alphaTolerance;
InternalEditorBridge.GenerateOutline(textureDataProvider.texture, rect, 1f, alphaTolerance, holeDetection, out paths);
if (paths.Length > 0)
{
ClipPaths(ref paths);
Debug.Assert(paths.Length > 0);
var rectSizeMagnitude = rect.size.magnitude;
var minDistance = Mathf.Max(rectSizeMagnitude / 10f, kMinLinearizeDistance);
var maxDistance = Mathf.Max(rectSizeMagnitude / 100f, kMinLinearizeDistance);
var distance = Mathf.Lerp(minDistance, maxDistance, detail);
for (var pathIndex = 0; pathIndex < paths.Length; ++pathIndex)
{
var pathLength = CalculatePathLength(paths[pathIndex]);
if (pathLength > distance)
{
var newPath = Linearize(new List <Vector2>(paths[pathIndex]), distance);
if (newPath.Count > 3)
{
paths[pathIndex] = newPath.ToArray();
}
SmoothPath(paths[pathIndex], 5, 0.1f, 135f);
}
}
ClipPaths(ref paths);
}
}
private void Init(Rect buttonRect, SpriteFrameModule sf, ITextureDataProvider dataProvider)
{
// Create for once if setting was not created before.
if (s_Setting == null)
{
s_Setting = CreateInstance <SpriteEditorMenuSetting>();
}
m_SpriteFrameModule = sf;
m_TextureDataProvider = dataProvider;
buttonRect = GUIUtility.GUIToScreenRect(buttonRect);
float windowHeight = 195;
var windowSize = new Vector2(300, windowHeight);
ShowAsDropDown(buttonRect, windowSize);
Undo.undoRedoPerformed += UndoRedoPerformed;
}
internal static bool ShowAtPosition(Rect buttonRect, SpriteFrameModule sf, ITextureDataProvider textureProvider)
{
// We could not use realtimeSinceStartUp since it is set to 0 when entering/exitting playmode, we assume an increasing time when comparing time.
long nowMilliSeconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
bool justClosed = nowMilliSeconds < s_LastClosedTime + 50;
if (!justClosed)
{
if (UnityEvent.current != null) // Event.current can be null during integration test
{
UnityEvent.current.Use();
}
SpriteEditorMenu spriteEditorMenu = CreateInstance <SpriteEditorMenu>();
spriteEditorMenu.Init(buttonRect, sf, textureProvider);
return(true);
}
return(false);
}
// implements ISpriteEditorModule
public override void OnModuleActivate()
{
spriteImportMode = SpriteFrameModule.GetSpriteImportMode(spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
m_TextureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_SpriteDataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int width, height;
m_TextureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
textureActualWidth = width;
textureActualHeight = height;
m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
m_RectsCache.hideFlags = HideFlags.HideAndDontSave;
m_RectsCache.spriteRects = m_SpriteDataProvider.GetSpriteRects().ToList();
spriteEditor.spriteRects = m_RectsCache.spriteRects;
if (spriteEditor.selectedSpriteRect != null)
{
spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID);
}
AddMainUI(spriteEditor.GetMainVisualContainer());
undoSystem.RegisterUndoCallback(UndoCallback);
}
internal static bool ShowAtPosition(Rect buttonRect, SpriteFrameModule sf, ITextureDataProvider textureProvider)
{
long num = DateTime.Now.Ticks / 10000L;
bool result;
if (num >= SpriteEditorMenu.s_LastClosedTime + 50L)
{
if (Event.current != null)
{
Event.current.Use();
}
SpriteEditorMenu spriteEditorMenu = ScriptableObject.CreateInstance <SpriteEditorMenu>();
spriteEditorMenu.Init(buttonRect, sf, textureProvider);
result = true;
}
else
{
result = false;
}
return(result);
}
private void CreateMeshCache(SpriteCache sprite, ISpriteMeshDataProvider meshProvider, ITextureDataProvider textureDataProvider)
{
Debug.Assert(m_SkeletonMap.ContainsKey(sprite));
var guid = new GUID(sprite.id);
var mesh = CreateCache <MeshCache>();
var skeleton = m_SkeletonMap[sprite] as SkeletonCache;
var metaVertices = meshProvider.GetVertices(guid);
mesh.sprite = sprite;
mesh.SetCompatibleBoneSet(skeleton.bones);
foreach (var mv in metaVertices)
{
var v = new Vertex2D(mv.position, mv.boneWeight);
mesh.vertices.Add(v);
}
mesh.indices = new List <int>(meshProvider.GetIndices(guid));
var edges = meshProvider.GetEdges(guid);
foreach (var e in edges)
{
mesh.edges.Add(new Edge(e.x, e.y));
}
mesh.textureDataProvider = textureDataProvider;
m_MeshMap[sprite] = mesh;
}
protected static List <SpriteOutline> GenerateSpriteRectOutline(Rect rect, float detail, byte alphaTolerance, ITextureDataProvider textureProvider)
{
List <SpriteOutline> list = new List <SpriteOutline>();
UnityEngine.Texture2D texture = textureProvider.texture;
if (texture != null)
{
int num = 0;
int num2 = 0;
textureProvider.GetTextureActualWidthAndHeight(out num, out num2);
int width = texture.width;
int height = texture.height;
Vector2 vector = new Vector2((float)width / (float)num, (float)height / (float)num2);
Rect rect2 = rect;
rect2.xMin *= vector.x;
rect2.xMax *= vector.x;
rect2.yMin *= vector.y;
rect2.yMax *= vector.y;
Vector2[][] array;
UnityEditor.Sprites.SpriteUtility.GenerateOutline(texture, rect2, detail, alphaTolerance, true, out array);
Rect r = default(Rect);
r.size = rect.size;
r.center = Vector2.zero;
for (int i = 0; i < array.Length; i++)
{
SpriteOutline spriteOutline = new SpriteOutline();
Vector2[] array2 = array[i];
for (int j = 0; j < array2.Length; j++)
{
Vector2 vector2 = array2[j];
spriteOutline.Add(SpriteOutlineModule.CapPointToRect(new Vector2(vector2.x / vector.x, vector2.y / vector.y), r));
}
list.Add(spriteOutline);
}
}
return(list);
}
protected static List <SpriteOutline> GenerateSpriteRectOutline(Rect rect, float detail, byte alphaTolerance, ITextureDataProvider textureProvider)
{
List <SpriteOutline> outline = new List <SpriteOutline>();
var texture = textureProvider.GetReadableTexture2D();
if (texture != null)
{
Vector2[][] paths;
// we might have a texture that is capped because of max size or NPOT.
// in that case, we need to convert values from capped space to actual texture space and back.
int actualWidth = 0, actualHeight = 0;
int cappedWidth, cappedHeight;
textureProvider.GetTextureActualWidthAndHeight(out actualWidth, out actualHeight);
cappedWidth = texture.width;
cappedHeight = texture.height;
Vector2 scale = new Vector2(cappedWidth / (float)actualWidth, cappedHeight / (float)actualHeight);
Rect spriteRect = rect;
spriteRect.xMin *= scale.x;
spriteRect.xMax *= scale.x;
spriteRect.yMin *= scale.y;
spriteRect.yMax *= scale.y;
UnityEditor.Sprites.SpriteUtility.GenerateOutline(texture, spriteRect, detail, alphaTolerance, true, out paths);
Rect capRect = new Rect();
capRect.size = rect.size;
capRect.center = Vector2.zero;
for (int j = 0; j < paths.Length; ++j)
{
SpriteOutline points = new SpriteOutline();
foreach (Vector2 v in paths[j])
{
points.Add(CapPointToRect(new Vector2(v.x / scale.x, v.y / scale.y), capRect));
}
outline.Add(points);
}
}
return(outline);
}
