public static int CompairIsoSortersBasic(IsoSpriteSorting sprite1, IsoSpriteSorting sprite2)
{
float y1 = sprite1.sortType == SortType.Point ? sprite1.SortingPoint1.y : sprite1.SortingLineCenterHeight;
float y2 = sprite2.sortType == SortType.Point ? sprite2.SortingPoint1.y : sprite2.SortingLineCenterHeight;
return(y2.CompareTo(y1));
}
public static void Visit(IsoSpriteSorting item, List <IsoSpriteSorting> sorted, Dictionary <IsoSpriteSorting, bool> visited)
{
bool inProcess;
var alreadyVisited = visited.TryGetValue(item, out inProcess);
if (alreadyVisited)
{
//if (inProcess)
//{
// string result = "";
// for (int i = 0; i < item.dependencies.Count; i++)
// {
// result += item.dependencies[i].name + System.Environment.NewLine;
// }
// UnityEngine.Debug.Log("Cyclic dependency found: " + item.name);
// UnityEngine.Debug.Log(result);
//}
}
else
{
visited[item] = true;
List <IsoSpriteSorting> dependencies = item.ActiveDependencies;
for (int i = 0; i < dependencies.Count; i++)
{
Visit(dependencies[i], sorted, visited);
}
visited[item] = false;
sorted.Add(item);
}
}
public static int CompairIsoSortersBasic(IsoSpriteSorting sprite1, IsoSpriteSorting sprite2)
{
float y1 = sprite1.SortingPoint1.y;
float y2 = sprite2.SortingPoint1.y;
return(y2.CompareTo(y1));
}
public static void RegisterSprite(IsoSpriteSorting newSprite)
{
if (!newSprite.registered)
{
if (newSprite.renderBelowAll)
{
floorSpriteList.Add(newSprite);
SortListSimple(floorSpriteList);
SetSortOrderNegative(floorSpriteList);
}
else
{
if (newSprite.isMovable)
{
moveableSpriteList.Add(newSprite);
}
else
{
staticSpriteList.Add(newSprite);
newSprite.SetupStaticCache();
SetupStaticDependencies(newSprite);
}
}
newSprite.registered = true;
}
}
public static void FilterListByVisibility(List <IsoSpriteSorting> fullList, List <IsoSpriteSorting> destinationList)
{
destinationList.Clear();
int count = fullList.Count;
for (int i = 0; i < count; i++)
{
IsoSpriteSorting sprite = fullList[i];
if (sprite.forceSort)
{
destinationList.Add(sprite);
sprite.forceSort = false;
}
else
{
for (int j = 0; j < sprite.renderersToSort.Length; j++)
{
if (sprite.renderersToSort[j].isVisible)
{
destinationList.Add(sprite);
break;
}
}
}
}
}
public void OnSceneGUI()
{
IsoSpriteSorting myTarget = (IsoSpriteSorting)target;
myTarget.SorterPositionOffset = Handles.FreeMoveHandle(
myTarget.transform.position + myTarget.SorterPositionOffset,
Quaternion.identity,
0.08f * HandleUtility.GetHandleSize(myTarget.transform.position),
Vector3.zero,
Handles.DotHandleCap
) - myTarget.transform.position;
if (myTarget.sortType == IsoSpriteSorting.SortType.Line)
{
myTarget.SorterPositionOffset2 = Handles.FreeMoveHandle(
myTarget.transform.position + myTarget.SorterPositionOffset2,
Quaternion.identity,
0.08f * HandleUtility.GetHandleSize(myTarget.transform.position),
Vector3.zero,
Handles.DotHandleCap
) - myTarget.transform.position;
Handles.DrawLine(myTarget.transform.position + myTarget.SorterPositionOffset, myTarget.transform.position + myTarget.SorterPositionOffset2);
}
if (GUI.changed)
{
Undo.RecordObject(target, "Updated Sorting Offset");
EditorUtility.SetDirty(target);
}
}
private static void RemoveStaticDependencies(IsoSpriteSorting spriteToRemove)
{
for (int i = 0; i < spriteToRemove.inverseStaticDependencies.Count; i++)
{
IsoSpriteSorting otherSprite = spriteToRemove.inverseStaticDependencies[i];
otherSprite.staticDependencies.Remove(spriteToRemove);
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
IsoSpriteSorting myScript = (IsoSpriteSorting)target;
if (GUILayout.Button("Sort Visible Scene"))
{
myScript.SortScene();
}
}
public static void UnregisterSprite(IsoSpriteSorting spriteToRemove)
{
if (spriteToRemove.renderBelowAll)
{
floorSpriteList.Remove(spriteToRemove);
}
else
{
moveableSpriteList.Remove(spriteToRemove);
}
}
private static void RemoveCircularDependencyFromStack(List <IsoSpriteSorting> _circularReferenceStack)
{
if (_circularReferenceStack.Count > 1)
{
IsoSpriteSorting startingSorter = _circularReferenceStack[_circularReferenceStack.Count - 1];
int repeatIndex = 0;
for (int i = _circularReferenceStack.Count - 2; i >= 0; i--)
{
IsoSpriteSorting sorter = _circularReferenceStack[i];
if (sorter == startingSorter)
{
repeatIndex = i;
break;
}
}
int weakestDepIndex = -1;
float longestDistance = float.MinValue;
for (int i = repeatIndex; i < _circularReferenceStack.Count - 1; i++)
{
IsoSpriteSorting sorter1a = _circularReferenceStack[i];
IsoSpriteSorting sorter2a = _circularReferenceStack[i + 1];
if (sorter1a.sortType == IsoSpriteSorting.SortType.Point && sorter2a.sortType == IsoSpriteSorting.SortType.Point)
{
float dist = UnityEngine.Mathf.Abs(sorter1a.AsPoint.x - sorter2a.AsPoint.x);
if (dist > longestDistance)
{
weakestDepIndex = i;
longestDistance = dist;
}
}
}
if (weakestDepIndex == -1)
{
for (int i = repeatIndex; i < _circularReferenceStack.Count - 1; i++)
{
IsoSpriteSorting sorter1a = _circularReferenceStack[i];
IsoSpriteSorting sorter2a = _circularReferenceStack[i + 1];
float dist = UnityEngine.Mathf.Abs(sorter1a.AsPoint.x - sorter2a.AsPoint.x);
if (dist > longestDistance)
{
weakestDepIndex = i;
longestDistance = dist;
}
}
}
IsoSpriteSorting sorter1 = _circularReferenceStack[weakestDepIndex];
IsoSpriteSorting sorter2 = _circularReferenceStack[weakestDepIndex + 1];
sorter1.VisibleStaticDependencies.Remove(sorter2);
sorter1.VisibleMovingDependencies.Remove(sorter2);
}
}
public static void RegisterSprite(IsoSpriteSorting newSprite)
{
if (newSprite.renderBelowAll)
{
floorSpriteList.Add(newSprite);
SortListSimple(floorSpriteList);
SetSortOrderNegative(floorSpriteList);
}
else
{
moveableSpriteList.Add(newSprite);
}
}
private static void SortListSimple(List <IsoSpriteSorting> list)
{
list.Sort((a, b) =>
{
if (!a || !b)
{
return(0);
}
else
{
return(IsoSpriteSorting.CompareIsoSorters(a, b));
}
});
}
private static int CompareLineAndLine(IsoSpriteSorting line1, IsoSpriteSorting line2)
{
Vector2 line1Point1 = line1.SortingPoint1;
Vector2 line1Point2 = line1.SortingPoint2;
Vector2 line2Point1 = line2.SortingPoint1;
Vector2 line2Point2 = line2.SortingPoint2;
int comp1 = ComparePointAndLine(line1Point1, line2);
int comp2 = ComparePointAndLine(line1Point2, line2);
int oneVStwo = int.MinValue;
if (comp1 == comp2)
{
oneVStwo = comp1;
}
int comp3 = ComparePointAndLine(line2Point1, line1);
int comp4 = ComparePointAndLine(line2Point2, line1);
int twoVSone = int.MinValue;
if (comp3 == comp4)
{
twoVSone = -comp3;
}
if (oneVStwo != int.MinValue && twoVSone != int.MinValue)
{
if (oneVStwo == twoVSone)
{
return(oneVStwo);
}
return(CompareLineCenters(line1, line2));
}
else if (oneVStwo != int.MinValue)
{
return(oneVStwo);
}
else if (twoVSone != int.MinValue)
{
return(twoVSone);
}
else
{
return(CompareLineCenters(line1, line2));
}
}
private static int CompareLineAndLine(IsoSpriteSorting line1, IsoSpriteSorting line2)
{
Vector2 line1Point1 = line1.SortingPoint1;
Vector2 line1Point2 = line1.SortingPoint2;
Vector2 line2Point1 = line2.SortingPoint1;
Vector2 line2Point2 = line2.SortingPoint2;
int comp1 = ComparePointAndLine(line1Point1, line2);
int comp2 = ComparePointAndLine(line1Point2, line2);
int oneVStwo = int.MinValue;
if (comp1 == comp2) //Both points in line 1 are above or below line2
{
oneVStwo = comp1;
}
int comp3 = ComparePointAndLine(line2Point1, line1);
int comp4 = ComparePointAndLine(line2Point2, line1);
int twoVSone = int.MinValue;
if (comp3 == comp4) //Both points in line 2 are above or below line1
{
twoVSone = -comp3;
}
if (oneVStwo != int.MinValue && twoVSone != int.MinValue)
{
if (oneVStwo == twoVSone) //the two comparisons agree about the ordering
{
return(oneVStwo);
}
return(CompareLineCenters(line1, line2));
}
else if (oneVStwo != int.MinValue)
{
return(oneVStwo);
}
else if (twoVSone != int.MinValue)
{
return(twoVSone);
}
else
{
return(CompareLineCenters(line1, line2));
}
}
public static void UnregisterSprite(IsoSpriteSorting spriteToRemove)
{
if (spriteToRemove.renderBelowAll)
{
floorSpriteList.Remove(spriteToRemove);
}
else
{
if (spriteToRemove.isMovable)
{
moveableSpriteList.Remove(spriteToRemove);
}
else
{
staticSpriteList.Remove(spriteToRemove);
RemoveStaticDependencies(spriteToRemove);
}
}
}
private static void AddMovingDependenciesToMovingSprites(List <IsoSpriteSorting> moveableList)
{
for (int i = 0; i < moveableList.Count; i++)
{
IsoSpriteSorting sprite1 = moveableList[i];
for (int j = 0; j < moveableList.Count; j++)
{
IsoSpriteSorting sprite2 = moveableList[j];
if (CalculateBoundsIntersection(sprite1, sprite2))
{
int compareResult = IsoSpriteSorting.CompareIsoSorters(sprite1, sprite2);
if (compareResult == -1)
{
sprite2.movingDependencies.Add(sprite1);
}
}
}
}
}
private static int ComparePointAndLine(Vector3 point, IsoSpriteSorting line)
{
float pointY = point.y;
if (pointY > line.SortingPoint1.y && pointY > line.SortingPoint2.y)
{
return(-1);
}
else if (pointY < line.SortingPoint1.y && pointY < line.SortingPoint2.y)
{
return(1);
}
else
{
float slope = (line.SortingPoint2.y - line.SortingPoint1.y) / (line.SortingPoint2.x - line.SortingPoint1.x);
float intercept = line.SortingPoint1.y - (slope * line.SortingPoint1.x);
float yOnLineForPoint = (slope * point.x) + intercept;
return(yOnLineForPoint > point.y ? 1 : -1);
}
}
private static void AddMovingDependencies(List <IsoSpriteSorting> moveableList, List <IsoSpriteSorting> staticList)
{
int moveableCount = moveableList.Count;
int staticCount = staticList.Count;
for (int i = 0; i < moveableCount; i++)
{
IsoSpriteSorting moveSprite1 = moveableList[i];
//Add Moving Dependencies to static sprites
for (int j = 0; j < staticCount; j++)
{
IsoSpriteSorting staticSprite = staticList[j];
if (CalculateBoundsIntersection(moveSprite1, staticSprite))
{
int compareResult = IsoSpriteSorting.CompareIsoSorters(moveSprite1, staticSprite);
if (compareResult == -1)
{
staticSprite.movingDependencies.Add(moveSprite1);
}
else if (compareResult == 1)
{
moveSprite1.movingDependencies.Add(staticSprite);
}
}
}
//Add Moving Dependencies to Moving Sprites
for (int j = 0; j < moveableCount; j++)
{
IsoSpriteSorting moveSprite2 = moveableList[j];
if (CalculateBoundsIntersection(moveSprite1, moveSprite2))
{
int compareResult = IsoSpriteSorting.CompareIsoSorters(moveSprite1, moveSprite2);
if (compareResult == -1)
{
moveSprite2.movingDependencies.Add(moveSprite1);
}
}
}
}
}
private static void SetupStaticDependencies(IsoSpriteSorting newSprite)
{
int the_count = staticSpriteList.Count;
for (int i = 0; i < the_count; i++)
{
IsoSpriteSorting otherSprite = staticSpriteList[i];
if (CalculateBoundsIntersection(newSprite, otherSprite))
{
int compareResult = IsoSpriteSorting.CompareIsoSorters(newSprite, otherSprite);
if (compareResult == -1)
{
otherSprite.staticDependencies.Add(newSprite);
newSprite.inverseStaticDependencies.Add(otherSprite);
}
else if (compareResult == 1)
{
newSprite.staticDependencies.Add(otherSprite);
otherSprite.inverseStaticDependencies.Add(newSprite);
}
}
}
}
public static int CompareIsoSorters(IsoSpriteSorting sprite1, IsoSpriteSorting sprite2)
{
if (sprite1.sortType == SortType.Point && sprite2.sortType == SortType.Point)
{
return(sprite2.SortingPoint1.y.CompareTo(sprite1.SortingPoint1.y));
}
else if (sprite1.sortType == SortType.Line && sprite2.sortType == SortType.Line)
{
return(CompareLineAndLine(sprite1, sprite2));
}
else if (sprite1.sortType == SortType.Point && sprite2.sortType == SortType.Line)
{
return(ComparePointAndLine(sprite1.SortingPoint1, sprite2));
}
else if (sprite1.sortType == SortType.Line && sprite2.sortType == SortType.Point)
{
return(-ComparePointAndLine(sprite2.SortingPoint1, sprite1));
}
else
{
return(0);
}
}
private static void AddMovingDependenciesToStaticSprites(List <IsoSpriteSorting> moveableList, List <IsoSpriteSorting> staticList)
{
for (int i = 0; i < moveableList.Count; i++)
{
IsoSpriteSorting moveSprite = moveableList[i];
for (int j = 0; j < staticList.Count; j++)
{
IsoSpriteSorting staticSprite = staticList[j];
if (CalculateBoundsIntersection(moveSprite, staticSprite))
{
int compareResult = IsoSpriteSorting.CompareIsoSorters(moveSprite, staticSprite);
if (compareResult == -1)
{
staticSprite.movingDependencies.Add(moveSprite);
}
else if (compareResult == 1)
{
moveSprite.movingDependencies.Add(staticSprite);
}
}
}
}
}
private static void Visit(IsoSpriteSorting item, List <IsoSpriteSorting> sorted, HashSet <int> visited)
{
int id = item.GetInstanceID();
if (!visited.Contains(id))
{
visited.Add(id);
List <IsoSpriteSorting> dependencies = item.VisibleMovingDependencies;
int dcount = dependencies.Count;
for (int i = 0; i < dcount; i++)
{
Visit(dependencies[i], sorted, visited);
}
dependencies = item.VisibleStaticDependencies;
dcount = dependencies.Count;
for (int i = 0; i < dcount; i++)
{
Visit(dependencies[i], sorted, visited);
}
sorted.Add(item);
}
}
private static int CompareLineCenters(IsoSpriteSorting line1, IsoSpriteSorting line2)
{
return(-line1.SortingLineCenterHeight.CompareTo(line2.SortingLineCenterHeight));
}
private static bool CalculateBoundsIntersection(IsoSpriteSorting sprite, IsoSpriteSorting otherSprite)
{
return(sprite.TheBounds.Intersects(otherSprite.TheBounds));
}
