public static int CompairIsoSortersBasic(SpriteSorting sprite1, SpriteSorting 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));
}
private static void RemoveStaticDependencies(SpriteSorting spriteToRemove)
{
for (int i = 0; i < spriteToRemove.inverseStaticDependencies.Count; i++)
{
SpriteSorting otherSprite = spriteToRemove.inverseStaticDependencies[i];
otherSprite.staticDependencies.Remove(spriteToRemove);
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
SpriteSorting myScript = (SpriteSorting)target;
if (GUILayout.Button("Sort Visibles"))
{
myScript.SortScene();
}
}
public void OnSceneGUI()
{
SpriteSorting myTarget = (SpriteSorting)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 (GUI.changed)
{
Undo.RecordObject(target, "Updated Sorting Offset");
EditorUtility.SetDirty(target);
}
}
private static void SortListSimple(List <SpriteSorting> list)
{
list.Sort((a, b) =>
{
if (!a || !b)
{
return(0);
}
else
{
return(SpriteSorting.CompareIsoSorters(a, b));
}
});
}
private static int CompareLineAndLine(SpriteSorting line1, SpriteSorting 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));
}
}
public static void UnregisterSprite(SpriteSorting 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 <SpriteSorting> moveableList)
{
for (int i = 0; i < moveableList.Count; i++)
{
SpriteSorting sprite1 = moveableList[i];
for (int j = 0; j < moveableList.Count; j++)
{
SpriteSorting sprite2 = moveableList[j];
if (CalculateBoundsIntersection(sprite1, sprite2))
{
int compareResult = SpriteSorting.CompareIsoSorters(sprite1, sprite2);
if (compareResult == -1)
{
sprite2.movingDependencies.Add(sprite1);
}
}
}
}
}
public static void Visit(SpriteSorting item, List <SpriteSorting> sorted, Dictionary <SpriteSorting, bool> visited)
{
bool inProcess;
var alreadyVisited = visited.TryGetValue(item, out inProcess);
if (!alreadyVisited)
{
visited[item] = true;
List <SpriteSorting> dependencies = item.ActiveDependencies;
for (int i = 0; i < dependencies.Count; i++)
{
Visit(dependencies[i], sorted, visited);
}
visited[item] = false;
sorted.Add(item);
}
}
private static int ComparePointAndLine(Vector3 point, SpriteSorting 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);
}
}
public static void RegisterSprite(SpriteSorting newSprite)
{
if (newSprite.renderBelowAll)
{
floorSpriteList.Add(newSprite);
SortListSimple(floorSpriteList);
SetSortOrderNegative(floorSpriteList);
}
else
{
if (newSprite.isMovable)
{
moveableSpriteList.Add(newSprite);
}
else
{
staticSpriteList.Add(newSprite);
SetupStaticDependencies(newSprite);
}
}
}
private static void AddMovingDependenciesToStaticSprites(List <SpriteSorting> moveableList, List <SpriteSorting> staticList)
{
for (int i = 0; i < moveableList.Count; i++)
{
SpriteSorting moveSprite = moveableList[i];
for (int j = 0; j < staticList.Count; j++)
{
SpriteSorting staticSprite = staticList[j];
if (CalculateBoundsIntersection(moveSprite, staticSprite))
{
int compareResult = SpriteSorting.CompareIsoSorters(moveSprite, staticSprite);
if (compareResult == -1)
{
staticSprite.movingDependencies.Add(moveSprite);
}
else if (compareResult == 1)
{
moveSprite.movingDependencies.Add(staticSprite);
}
}
}
}
}
public static int CompareIsoSorters(SpriteSorting sprite1, SpriteSorting 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 SetupStaticDependencies(SpriteSorting newSprite)
{
int the_count = staticSpriteList.Count;
for (int i = 0; i < the_count; i++)
{
SpriteSorting otherSprite = staticSpriteList[i];
if (CalculateBoundsIntersection(newSprite, otherSprite))
{
int compareResult = SpriteSorting.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 void FilterListByVisibility(List <SpriteSorting> fullList, List <SpriteSorting> destinationList)
{
destinationList.Clear();
for (int i = 0; i < fullList.Count; i++)
{
SpriteSorting 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;
}
}
}
}
}
private static int CompareLineCenters(SpriteSorting line1, SpriteSorting line2)
{
return(-line1.SortingLineCenterHeight.CompareTo(line2.SortingLineCenterHeight));
}
private static bool CalculateBoundsIntersection(SpriteSorting sprite, SpriteSorting otherSprite)
{
return(sprite.TheBounds.Intersects(otherSprite.TheBounds));
}
