public void TestSetup()
{
m_BoneDataProvider = Substitute.For <ISpriteBoneDataProvider>();
m_SpriteEditor = Substitute.For <ISpriteEditor>();
m_SR1 = new SpriteRect();
m_SR2 = new SpriteRect();
m_SR1.spriteID = new GUID()
{
};
List <SpriteBone> bones1 = new List <SpriteBone>();
bones1.Add(new SpriteBone()
{
name = "root1", parentId = -1, rotation = Quaternion.identity
});
m_BoneDataProvider.GetBones(m_SR1.spriteID).Returns(bones1);
List <SpriteBone> bones2 = new List <SpriteBone>();
bones2.Add(new SpriteBone()
{
name = "root2", parentId = -1, rotation = Quaternion.identity
});
m_BoneDataProvider.GetBones(m_SR2.spriteID).Returns(bones2);
m_SpriteEditor.GetDataProvider <ISpriteBoneDataProvider>().Returns(m_BoneDataProvider);
m_Module = new BoneSpriteEditorModule();
var prop = m_Module.GetType().GetProperty("spriteEditor");
prop.SetValue(m_Module, m_SpriteEditor, null);
}
protected virtual void SetupShapeEditorOutline(SpriteRect spriteRect)
{
var outline = m_Outline[spriteRect.spriteID];
var outlines = GenerateSpriteRectOutline(spriteRect.rect,
Math.Abs(outline.tessellationDetail - (-1f)) < Mathf.Epsilon ? 0 : outline.tessellationDetail,
0, m_TextureDataProvider);
if (outlines.Count == 0)
{
Vector2 halfSize = spriteRect.rect.size * 0.5f;
outlines = new List <SpriteOutline>()
{
new SpriteOutline()
{
m_Path = new List <Vector2>()
{
new Vector2(-halfSize.x, -halfSize.y),
new Vector2(-halfSize.x, halfSize.y),
new Vector2(halfSize.x, halfSize.y),
new Vector2(halfSize.x, -halfSize.y),
}
}
};
}
m_Outline[spriteRect.spriteID].spriteOutlines = outlines;
}
public void OnModuleDeactivate()
{
this.undoSystem.UnregisterUndoCallback(new Undo.UndoRedoCallback(this.UndoRedoPerformed));
this.CleanupShapeEditors();
this.m_Selected = null;
this.spriteEditorWindow.enableMouseMoveEvent = false;
}
private void AddSprite(Rect frame, int alignment, Vector2 pivot, AutoSlicingMethod slicingMethod, ref int index)
{
if (slicingMethod != AutoSlicingMethod.DeleteAll)
{
// Smart: Whenever we overlap, we just modify the existing rect and keep its other properties
// Safe: We only add new rect if it doesn't overlap existing one
SpriteRect existingSprite = GetExistingOverlappingSprite(frame);
if (existingSprite != null)
{
if (slicingMethod == AutoSlicingMethod.Smart)
{
existingSprite.rect = frame;
existingSprite.alignment = (SpriteAlignment)alignment;
existingSprite.pivot = pivot;
}
}
else
{
AddSpriteWithUniqueName(frame, alignment, pivot, kDefaultColliderAlphaCutoff, kDefaultColliderDetail, index++, Vector4.zero);
}
}
else
{
AddSprite(frame, alignment, pivot, kDefaultColliderAlphaCutoff, kDefaultColliderDetail, GetSpriteNamePrefix() + "_" + index++, Vector4.zero);
}
}
public void SpriteRectDataProvider_AddSpriteRectPersistAfterReimport(SpriteImportMode mode, bool mosaicLayer, int expectedSprite, bool expectAdd)
{
var so = new SerializedObject(m_Importer);
var textureImporterSettingsSP = so.FindProperty("m_TextureImporterSettings");
textureImporterSettingsSP.FindPropertyRelative("m_SpriteMode").intValue = (int)mode;
so.FindProperty("m_MosaicLayers").boolValue = mosaicLayer;
so.ApplyModifiedProperties();
var spriteProvider = m_Importer.GetDataProvider <ISpriteEditorDataProvider>();
var rects = spriteProvider.GetSpriteRects().ToList();
var newRect = new SpriteRect();
newRect.name = "Test";
newRect.rect = new Rect(0, 0, 32, 32);
rects.Add(newRect);
spriteProvider.SetSpriteRects(rects.ToArray());
spriteProvider.Apply();
m_Importer.SaveAndReimport();
var importer = AssetImporter.GetAtPath(m_Importer.assetPath) as PSDImporter;
spriteProvider = importer.GetDataProvider <ISpriteEditorDataProvider>();
Assert.AreEqual(expectedSprite, spriteProvider.GetSpriteRects().Length);
Assert.AreEqual(expectAdd, spriteProvider.GetSpriteRects().FirstOrDefault(x => x.spriteID == newRect.spriteID) != null);
Assert.AreEqual(expectedSprite, AssetDatabase.LoadAllAssetsAtPath(m_Importer.assetPath).Count(x => x is Sprite));
}
private void AddSprite(Rect frame, int alignment, Vector2 pivot, AutoSlicingMethod slicingMethod, ref int index)
{
if (slicingMethod != AutoSlicingMethod.DeleteAll)
{
// Smart: Whenever we overlap, we just modify the existing rect and keep its other properties
// Safe: We only add new rect if it doesn't overlap existing one
SpriteRect existingSprite = GetExistingOverlappingSprite(frame);
if (existingSprite != null)
{
if (slicingMethod == AutoSlicingMethod.Smart)
{
existingSprite.rect = frame;
existingSprite.alignment = (SpriteAlignment)alignment;
existingSprite.pivot = pivot;
}
}
else
{
while (AddSprite(frame, alignment, pivot, GenerateSpriteNameWithIndex(index++), Vector4.zero) == -1)
{
}
}
}
else
{
while (AddSprite(frame, alignment, pivot, GenerateSpriteNameWithIndex(index++), Vector4.zero) == -1)
{
}
}
}
static bool ConvertXml(string path)
{
try
{
Debug.Log("ConvertXml: " + path);
var xmlDoc = new XmlDocument();
xmlDoc.Load(path);
var subImages = xmlDoc.GetElementsByTagName("SubImage")
.OfType <XmlElement>()
.Select(element =>
{
var rect = new SpriteRect();
rect.name = element.GetAttribute("Name");
var args = element.GetAttribute("Rectangle").Split(',');
rect.rect = new Rect(int.Parse(args[0]), int.Parse(args[1]), int.Parse(args[2]), int.Parse(args[3]));
return(rect);
}).ToArray();
return(ConvertSprite(path, subImages));
}
catch (System.Exception ex)
{
Debug.LogError("Faile to load: " + path + ", Error: " + ex.Message);
return(false);
}
}
private SpriteRect TrySelect(Vector2 mousePosition)
{
float selectedSize = float.MaxValue;
SpriteRect currentRect = null;
mousePosition = Handles.inverseMatrix.MultiplyPoint(mousePosition);
for (int i = 0; i < m_RectsCache.Count; i++)
{
var sr = m_RectsCache[i];
if (sr.rect.Contains(mousePosition))
{
// If we clicked inside an already selected spriterect, always persist that selection
if (sr == selectedSpriteRect)
{
return(sr);
}
float width = sr.rect.width;
float height = sr.rect.height;
float newSize = width * height;
if (width > 0f && height > 0f && newSize < selectedSize)
{
currentRect = sr;
selectedSize = newSize;
}
}
}
return(currentRect);
}
static bool ConvertYaml(string path)
{
// LeftCymbal: [1, 0, 91, 98]
Debug.Log("ConvertYaml: " + path);
var subImages = File.ReadAllLines(path)
.Select(line => line.Trim())
.Where(line => line.Contains(':') && line[0] != '#' && line[line.Length - 1] == ']')
.Select(line =>
{
var sheet = new SpriteRect();
var start = 0;
var flag = line[start];
var end = line.LastIndexOf(':');
if (flag == '\'' || flag == '\"')
{
start = 1;
end = line.LastIndexOf(flag);
}
sheet.name = line.Substring(start, end - start);
if (string.IsNullOrEmpty(sheet.name) || sheet.name == "." || sheet.name == "/")
{
sheet.name = "\\" + sheet.name;
}
var args = line.Substring(line.LastIndexOf('[')).Split(Sperator, System.StringSplitOptions.RemoveEmptyEntries);
sheet.rect = new Rect(int.Parse(args[0]), int.Parse(args[1]), int.Parse(args[2]), int.Parse(args[3]));
return(sheet);
}).ToArray();
return(ConvertSprite(path, subImages));
}
protected virtual void SetupShapeEditorOutline(SpriteRect spriteRect)
{
if (spriteRect.outline == null || spriteRect.outline.Count == 0)
{
spriteRect.outline = SpriteOutlineModule.GenerateSpriteRectOutline(spriteRect.rect, this.spriteEditorWindow.selectedTexture, spriteRect.tessellationDetail, 0);
if (spriteRect.outline.Count == 0)
{
Vector2 vector = spriteRect.rect.size * 0.5f;
spriteRect.outline = new List <SpriteOutline>
{
new SpriteOutline
{
m_Path = new List <Vector2>
{
new Vector2(-vector.x, -vector.y),
new Vector2(-vector.x, vector.y),
new Vector2(vector.x, vector.y),
new Vector2(vector.x, -vector.y)
}
}
};
}
this.spriteEditorWindow.SetDataModified();
}
}
protected virtual void SetupShapeEditorOutline(SpriteRect spriteRect)
{
SpriteOutlineList spriteOutlineList = this.m_Outline[spriteRect.spriteID];
if (spriteOutlineList.spriteOutlines == null || spriteOutlineList.spriteOutlines.Count == 0)
{
List <SpriteOutline> list = SpriteOutlineModule.GenerateSpriteRectOutline(spriteRect.rect, (Math.Abs(spriteOutlineList.tessellationDetail - -1f) >= Mathf.Epsilon) ? spriteOutlineList.tessellationDetail : 0f, 0, this.m_TextureDataProvider);
if (list.Count == 0)
{
Vector2 vector = spriteRect.rect.size * 0.5f;
list = new List <SpriteOutline>
{
new SpriteOutline
{
m_Path = new List <Vector2>
{
new Vector2(-vector.x, -vector.y),
new Vector2(-vector.x, vector.y),
new Vector2(vector.x, vector.y),
new Vector2(vector.x, -vector.y)
}
}
};
}
this.m_Outline[spriteRect.spriteID].spriteOutlines = list;
}
}
protected virtual bool HasShapeOutline(SpriteRect spriteRect)
{
SpriteOutlineList expr_12 = this.m_Outline[spriteRect.spriteID];
List <SpriteOutline> list = (expr_12 != null) ? expr_12.spriteOutlines : null;
return(list != null && list.Count > 0);
}
public void AddRect(SpriteRect r)
{
if (m_Rects == null)
{
return;
}
m_Rects.Add(r);
}
public void SetSprite(string name)
{
SpriteRect rect = _spriteInfo.GetSprite(name);
Vector2 imgDimensions = new Vector2(_spriteTexture.width, _spriteTexture.height);
renderer.material.mainTextureOffset = rect.GetOffset(imgDimensions);
renderer.material.mainTextureScale = rect.GetScale(imgDimensions);
}
public int GetIndex(SpriteRect spriteRect)
{
if (m_Rects != null)
{
return(m_Rects.FindIndex((sp) => { return sp == spriteRect; }));
}
return(0);
}
public void RemoveRect(SpriteRect r)
{
if (m_Rects == null)
{
return;
}
m_Rects.Remove(r);
}
protected override void SetupShapeEditorOutline(SpriteRect spriteRect)
{
if (spriteRect.physicsShape == null || spriteRect.physicsShape.Count == 0)
{
spriteRect.physicsShape = SpriteOutlineModule.GenerateSpriteRectOutline(spriteRect.rect, this.spriteEditorWindow.selectedTexture, (Math.Abs(spriteRect.tessellationDetail - -1f) >= Mathf.Epsilon) ? spriteRect.tessellationDetail : this.kDefaultPhysicsTessellationDetail, this.kDefaultPhysicsAlphaTolerance);
this.spriteEditorWindow.SetDataModified();
}
}
public void CopyFromSpriteRect(SpriteRect spriteRect)
{
alignment = spriteRect.alignment;
border = spriteRect.border;
name = spriteRect.name;
pivot = spriteRect.pivot;
rect = spriteRect.rect;
spriteID = spriteRect.spriteID;
}
public bool Contains(SpriteRect spriteRect)
{
if (m_Rects != null)
{
return(m_Rects.Contains(spriteRect));
}
return(false);
}
public SpriteMetaData(SpriteRect sr)
{
alignment = sr.alignment;
border = sr.border;
name = sr.name;
pivot = GetPivotValue(sr.alignment, sr.pivot);
rect = sr.rect;
spriteID = sr.spriteID;
}
public void CopyFromSpriteRect(SpriteRect spriteRect)
{
base.alignment = spriteRect.alignment;
base.border = spriteRect.border;
base.name = spriteRect.name;
base.pivot = spriteRect.pivot;
base.rect = spriteRect.rect;
base.spriteID = spriteRect.spriteID;
}
public void SetupShapeEditor()
{
if (this.shapeEditorDirty || this.m_Selected != this.spriteEditorWindow.selectedSpriteRect)
{
this.m_Selected = this.spriteEditorWindow.selectedSpriteRect;
this.CleanupShapeEditors();
if (this.m_Selected != null)
{
this.SetupShapeEditorOutline(this.m_Selected);
this.selectedShapeOutline = this.m_Selected.outline;
this.m_ShapeEditors = new ShapeEditor[this.selectedShapeOutline.Count];
for (int i = 0; i < this.selectedShapeOutline.Count; i++)
{
int outlineIndex = i;
this.m_ShapeEditors[i] = this.shapeEditorFactory.CreateShapeEditor();
this.m_ShapeEditors[i].SetRectSelectionTool(this.m_ShapeSelectionUI);
this.m_ShapeEditors[i].LocalToWorldMatrix = (() => this.m_HandleMatrix);
this.m_ShapeEditors[i].LocalToScreen = ((Vector3 point) => Handles.matrix.MultiplyPoint(point));
this.m_ShapeEditors[i].ScreenToLocal = new Func <Vector2, Vector3>(this.ScreenToLocal);
this.m_ShapeEditors[i].RecordUndo = new Action(this.RecordUndo);
this.m_ShapeEditors[i].GetHandleSize = new Func <float>(this.GetHandleSize);
this.m_ShapeEditors[i].lineTexture = this.m_OutlineTexture;
this.m_ShapeEditors[i].Snap = new Func <Vector3, Vector3>(this.SnapPoint);
this.m_ShapeEditors[i].GetPointPosition = ((int index) => this.GetPointPosition(outlineIndex, index));
this.m_ShapeEditors[i].SetPointPosition = delegate(int index, Vector3 position)
{
this.SetPointPosition(outlineIndex, index, position);
};
this.m_ShapeEditors[i].InsertPointAt = delegate(int index, Vector3 position)
{
this.InsertPointAt(outlineIndex, index, position);
};
this.m_ShapeEditors[i].RemovePointAt = delegate(int index)
{
this.RemovePointAt(outlineIndex, index);
};
this.m_ShapeEditors[i].GetPointsCount = (() => this.GetPointsCount(outlineIndex));
}
for (int j = 0; j < this.selectedShapeOutline.Count; j++)
{
for (int k = 0; k < this.selectedShapeOutline.Count; k++)
{
if (j != k)
{
this.m_ShapeEditors[k].RegisterToShapeEditor(this.m_ShapeEditors[j]);
}
}
}
}
else
{
this.m_ShapeEditors = new ShapeEditor[0];
}
}
this.shapeEditorDirty = false;
}
protected override void SetupShapeEditorOutline(SpriteRect spriteRect)
{
var physicsShape = m_Outline[spriteRect.spriteID];
var physicsShapes = GenerateSpriteRectOutline(spriteRect.rect,
Math.Abs(physicsShape.tessellationDetail - (-1f)) < Mathf.Epsilon ? kDefaultPhysicsTessellationDetail : physicsShape.tessellationDetail,
kDefaultPhysicsAlphaTolerance, m_TextureDataProvider);
m_Outline[spriteRect.spriteID].spriteOutlines = physicsShapes;
spriteEditorWindow.SetDataModified();
}
public void Remove(SpriteRect spriteRect)
{
m_Names.Remove(spriteRect.name);
if (spriteRect.internalID != 0)
{
m_InternalIds.Remove(spriteRect.internalID);
}
m_SpriteRects.Remove(spriteRect);
m_SpriteReadOnlyList = m_SpriteRects.AsReadOnly();
}
internal SpriteDataExt(SpriteRect sr)
{
originalName = sr.originalName;
name = sr.name;
border = sr.border;
tessellationDetail = 0;
rect = sr.rect;
spriteID = sr.spriteID;
alignment = sr.alignment;
pivot = sr.pivot;
}
public OutlineSpriteRect(SpriteRect rect)
{
this.name = rect.name;
this.originalName = rect.originalName;
this.pivot = rect.pivot;
this.alignment = rect.alignment;
this.border = rect.border;
this.rect = rect.rect;
this.spriteID = rect.spriteID;
outlines = new List <Vector2[]>();
}
private SpriteCache CreateSpriteCache(SpriteRect spriteRect)
{
var sprite = CreateCache <SpriteCache>();
sprite.name = spriteRect.name;
sprite.id = spriteRect.spriteID.ToString();
sprite.textureRect = spriteRect.rect;
sprite.position = spriteRect.rect.position;
m_SpriteMap[sprite.id] = sprite;
return(sprite);
}
protected override void SetupShapeEditorOutline(SpriteRect spriteRect)
{
SpriteOutlineList spriteOutlineList = this.m_Outline[spriteRect.spriteID];
if (spriteOutlineList.spriteOutlines == null || spriteOutlineList.spriteOutlines.Count == 0)
{
List <SpriteOutline> spriteOutlines = SpriteOutlineModule.GenerateSpriteRectOutline(spriteRect.rect, (Math.Abs(spriteOutlineList.tessellationDetail - -1f) >= Mathf.Epsilon) ? spriteOutlineList.tessellationDetail : this.kDefaultPhysicsTessellationDetail, this.kDefaultPhysicsAlphaTolerance, this.m_TextureDataProvider);
this.spriteEditorWindow.SetDataModified();
this.m_Outline[spriteRect.spriteID].spriteOutlines = spriteOutlines;
}
}
public void AddSpriteData(SpriteRect spriteRect)
{
if (spriteImportMode != SpriteImportMode.Multiple)
{
Debug.LogWarning("Can only add sprite data when import mode is multiple");
}
else
{
GetSpriteImportData().Add(new SpriteMetaData(spriteRect));
}
}
public override string ToString()
{
string _return = SpriteName + "\n";
foreach (string s in _spriteInfo.Keys)
{
SpriteRect current = _spriteInfo[s];
_return += string.Format("{0}-({1}, {2}, {3}, {4})\n", s, current.x, current.y, current.Width, current.Height);
}
return(_return);
}
