rect.go

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package math

// Rect represents a rectangle.
type Rect struct {
	// Origin is the origin of the rectangle, typically the top left corner.
	Origin Pos
	// Size is the size of the rectangle, typically positive.
	Size Delta
}

// 3 l 2 = {3, 4}
// 3 l 1 = {3}
// 3 l 0 = {}
// 3 l -1 = {2}
// 3 l -2 = {2, 1}

// Normalized returns a rectangle such that its size is nonnegative.
func (r Rect) Normalized() Rect {
	if r.Size.DX < 0 {
		r.Origin.X += r.Size.DX
		r.Size.DX = -r.Size.DX
	}
	if r.Size.DY < 0 {
		r.Origin.Y += r.Size.DY
		r.Size.DY = -r.Size.DY
	}
	return r
}

func RectFromPoints(a, b Pos) Rect {
	var r Rect
	if a.X < b.X {
		r.Origin.X = a.X
		r.Size.DX = b.Y - a.X + 1
	} else {
		r.Origin.X = b.X
		r.Size.DX = a.Y - b.X + 1
	}
	if a.Y < b.Y {
		r.Origin.Y = a.Y
		r.Size.DY = b.Y - a.Y + 1
	} else {
		r.Origin.Y = b.Y
		r.Size.DY = a.Y - b.Y + 1
	}
	return r
}

// OppositeCorner returns the coordinate of the opposite corner of the rectangle. Only correct on normalized rectangles.
func (r Rect) OppositeCorner() Pos {
	return r.Origin.Add(r.Size).Sub(Delta{DX: 1, DY: 1})
}

// Center returns the coordinate in the middle of the rectangle.
func (r Rect) Center() Pos {
	return r.Origin.Add(r.Size.Div(2))
}

// Foot returns the coordinate in the bottom middle of the rectangle.
func (r Rect) Foot() Pos {
	return r.Origin.Add(Delta{DX: r.Size.DX / 2, DY: r.Size.DY - 1})
}

func intervalDistance(a0, a1, b0, b1 int) int {
	// If intervals are separated, compute separation amount.
	if b0 > a1 {
		return a1 - b0 // -1 when touching.
	}
	if a0 > b1 {
		return a0 - b1 // 1 when touching.
	}
	// Otherwise, we have b0 <= a1 && a0 <= b1. They overlap.
	return 0
}

// delta returns the vector between the closest points of two rectangles.
func (r Rect) delta(c10, c11 Pos) Delta {
	c00 := r.Origin
	c01 := r.OppositeCorner()
	xDist := intervalDistance(c00.X, c01.X, c10.X, c11.X)
	yDist := intervalDistance(c00.Y, c01.Y, c10.Y, c11.Y)
	return Delta{DX: xDist, DY: yDist}
}

// Delta returns the vector between the closest points of two rectangles.
func (r Rect) Delta(other Rect) Delta {
	return r.delta(other.Origin, other.OppositeCorner())
}

// DeltaPos returns the vector between the closest points of a rectangle and a point.
func (r Rect) DeltaPos(other Pos) Delta {
	return r.delta(other, other)
}