public Vector3 GridToWorld(Recti gridRect)
{
int width = gridRect.max.x - gridRect.min.x;
int height = gridRect.max.y - gridRect.min.y;
return(GridToWorld(gridRect.min.Float() + new Vector2(width / 2f, height / 2f)));
}
public Recti Constrain(Recti bounds) // Unchecked constrain
{
Recti constrained = this;
int offset = 0;
if (constrained.min.x < bounds.min.x) // Too left
{
offset = bounds.min.x - constrained.min.x;
}
if (constrained.max.x > bounds.max.x) // Too right
{
offset = bounds.max.x - constrained.max.x;
}
constrained.min.x += offset;
constrained.max.x += offset;
offset = 0;
if (constrained.min.y < bounds.min.y) // Too low
{
offset = bounds.min.y - constrained.min.y;
}
if (constrained.max.y > bounds.max.y) // Too high
{
offset = bounds.max.y - constrained.max.y;
}
constrained.min.y += offset;
constrained.max.y += offset;
return(constrained);
}
public Recti WorldToGrid(Vector3 center, Vector2Int size)
{
Vector2Int gridCenter = WorldToGrid(center);
//Debug.DrawRay(GridToWorld(gridCenter), Vector3.up, Color.yellow);
Vector2Int gridCenterFloored = (wtl.MultiplyPoint3x4(center) / settings.gridSnapStep).Flat().FloorToInt();
//Debug.DrawRay(GridToWorld(gridCenterFloored), Vector3.up, Color.red);
Recti gridRect = new Recti();
if (size.x % 2 != 0) // Odd
{
gridRect.min.x = gridCenterFloored.x - size.x / 2;
gridRect.max.x = gridCenterFloored.x + size.x / 2 + 1;
}
else // Even
{
gridRect.min.x = gridCenter.x - size.x / 2;
gridRect.max.x = gridCenter.x + size.x / 2;
}
if (size.y % 2 != 0) // Odd
{
gridRect.min.y = gridCenterFloored.y - size.y / 2;
gridRect.max.y = gridCenterFloored.y + size.y / 2 + 1;
}
else // Even
{
gridRect.min.y = gridCenter.y - size.y / 2;
gridRect.max.y = gridCenter.y + size.y / 2;
}
//Debug.DrawRay(GridToWorld(gridRect.min), Vector3.up, Color.green);
//Debug.DrawRay(GridToWorld(gridRect.max), Vector3.up, Color.cyan);
return(gridRect);
}
public float Distance(Recti rect)
{
if (Intersects(rect))
{
return(0f);
}
// Corners
Vector2Int localCorner;
Vector2Int otherCorner;
if (rect.min.x > max.x && rect.min.y > max.y) // Top right
{
localCorner = max;
otherCorner = rect.min;
return((otherCorner - localCorner).magnitude);
}
if (rect.max.x < min.x && rect.min.y > max.y) // Top left
{
localCorner = new Vector2Int(min.x, max.y);
otherCorner = new Vector2Int(rect.max.x, rect.min.y);
return((otherCorner - localCorner).magnitude);
}
if (rect.max.x < min.x && rect.max.y < min.y) // Bottom left
{
localCorner = min;
otherCorner = rect.max;
return((otherCorner - localCorner).magnitude);
}
if (rect.min.x > max.x && rect.max.y < min.y) // Bottom right
{
localCorner = new Vector2Int(max.x, min.y);
otherCorner = new Vector2Int(rect.min.x, rect.max.y);
return((otherCorner - localCorner).magnitude);
}
// Sides
if (rect.min.x > max.x) // Right
{
return(rect.min.x - max.x);
}
if (rect.max.x < min.x) // Left
{
return(min.x - rect.max.x);
}
if (rect.min.y > max.y) // Top
{
return(rect.min.y - max.y);
}
if (rect.max.y < min.y) // Bottom
{
return(min.y - rect.max.y);
}
return(0f); // Should not be possible
}
public bool Constrain(Recti bounds, out Recti constrained)
{
int width = max.x - min.x;
int height = max.y - min.y;
if (bounds.max.x - bounds.min.x < width || bounds.max.y - bounds.min.y < height)
{
constrained = this;
return(false);
}
constrained = Constrain(bounds);
return(true);
}
public Recti ProjectInGrid(Recti rect)
{
if (boundingRects.Count == 0)
{
return(rect);
}
Recti closest = rect.Constrain(boundingRects[0]);
float distClosest = Vector2.Distance(rect.center, closest.center);
for (int i = 1; i < boundingRects.Count; i++)
{
Recti currentClosest = rect.Constrain(boundingRects[i]);
float distCurrent = Vector2.Distance(rect.center, currentClosest.center);
if (distCurrent < distClosest)
{
closest = currentClosest;
}
}
return(closest);
}
public void Snap(Transform transf, Transform reference, Vector2Int size)
{
transf.rotation = SnapRotation(reference.rotation);
Vector3 euler = transf.rotation.eulerAngles;
euler.y -= transform.rotation.eulerAngles.y;
if (Mathf.RoundToInt(euler.y) == 90 || Mathf.RoundToInt(euler.y) == 270) // TODO kinda ugly check
{
int tmp = size.x;
size.x = size.y;
size.y = tmp;
}
euler.y += transform.rotation.eulerAngles.y;
Recti gridRect = WorldToGrid(reference.position, size);
if (!IsInGrid(gridRect))
{
gridRect = ProjectInGrid(gridRect); // TODO not perfect when rect is part in one rect part in another
}
//Debug.DrawRay(GridToWorld(gridRect.min), Vector3.up, Color.white);
//Debug.DrawRay(GridToWorld(gridRect.max), Vector3.up, Color.white);
transf.position = GridToWorld(gridRect);
}
public static Vector2Int Clamp(this Vector2Int v, Recti rect)
{
return(new Vector2Int((v.x < rect.min.x) ? rect.min.x : ((v.x > rect.max.x) ? rect.max.x : v.x), (v.y < rect.min.y) ? rect.min.y : ((v.y > rect.max.y) ? rect.max.y : v.y)));
}
public bool Intersects(Recti rect)
{
return(!(rect.min.x > max.x || rect.max.x < min.x || rect.min.y > max.y || rect.max.y < min.y));
}
public bool Contains(Recti rect)
{
return(!(rect.min.x < min.x || rect.min.y < min.y || rect.max.x > max.x || rect.max.y > max.y));
}
public bool IsInGrid(Recti gridRect)
{
return(IsInGrid(gridRect.min) && IsInGrid(new Vector2Int(gridRect.min.x, gridRect.max.y)) && IsInGrid(gridRect.max) && IsInGrid(new Vector2Int(gridRect.max.x, gridRect.min.y)));
}
public void AddBoundingRect(Recti rect)
{
boundingRects.Add(rect);
RecreateMesh(mesh, boundingRects);
}
