Adding ShapeFilter options.

Space.Shapes() now returns a ShpaeCollection.
Space.Width() / Height() is now in pixels, and I'm adding Space.WidthInCells / HeightInCells().
Adding Bounds.MinAxis() / MaxAxis().
FIX: Bounds.Intersection() was not returning the right intersecting bounds between two Bounds objects.
FIX: LineTest now no longer panics if the OnIntersect callback is not set.
FIX: Vector.Angle() is now a signed angle, rather than unsigned.
Adding ShapeFilter.First() / Last().
Renaming NewRectangleTopLeft > NewRectangleFromTopLeft.
Minor documentation fixes.

Author: SolarLune

convexPolygon.go

@@ -631,11 +631,11 @@ func NewRectangle(x, y, w, h float64) *ConvexPolygon {
 	)
 }
 
-// NewRectangleTopLeft returns a rectangular ConvexPolygon at the position given with the vertices ordered in clockwise order.
+// NewRectangleFromTopLeft returns a rectangular ConvexPolygon at the position given with the vertices ordered in clockwise order.
 // The Rectangle's origin will be the center of its shape (as is recommended for collision testing).
 // Note that the rectangle will be positioned such that x, y is the top-left corner, though the center-point is still
 // in the center of the ConvexPolygon shape.
-func NewRectangleTopLeft(x, y, w, h float64) *ConvexPolygon {
+func NewRectangleFromTopLeft(x, y, w, h float64) *ConvexPolygon {
 
 	r := NewRectangle(x, y, w, h)
 	r.Move(w/2, h/2)

examples/worldBouncer.go

@@ -45,12 +45,12 @@ func (w *WorldBouncer) Init() {
 
 	// Create a selection of shapes that comprise the walls.
 	w.Solids = resolv.ShapeCollection{
-		resolv.NewRectangleTopLeft(0, 0, 640, 16),
-		resolv.NewRectangleTopLeft(0, 360-16, 640, 16),
-		resolv.NewRectangleTopLeft(0, 16, 16, 360-16),
-		resolv.NewRectangleTopLeft(640-16, 16, 16, 360-16),
-		resolv.NewRectangleTopLeft(64, 128, 16, 200),
-		resolv.NewRectangleTopLeft(120, 300, 200, 8),
+		resolv.NewRectangleFromTopLeft(0, 0, 640, 16),
+		resolv.NewRectangleFromTopLeft(0, 360-16, 640, 16),
+		resolv.NewRectangleFromTopLeft(0, 16, 16, 360-16),
+		resolv.NewRectangleFromTopLeft(640-16, 16, 16, 360-16),
+		resolv.NewRectangleFromTopLeft(64, 128, 16, 200),
+		resolv.NewRectangleFromTopLeft(120, 300, 200, 8),
 	}
 
 	// Set their tags (not strictly necessary here because the bouncers bounce off of everything and anything)..

examples/worldCircleTest.go

@@ -27,12 +27,12 @@ func (w *WorldCircle) Init() {
 	w.space = resolv.NewSpace(640, 360, 16, 16)
 
 	solids := resolv.ShapeCollection{
-		resolv.NewRectangleTopLeft(0, 0, 640, 16),
-		resolv.NewRectangleTopLeft(0, 360-16, 640, 16),
-		resolv.NewRectangleTopLeft(0, 16, 16, 360-16),
-		resolv.NewRectangleTopLeft(640-16, 16, 16, 360-16),
-		resolv.NewRectangleTopLeft(64, 128, 16, 200),
-		resolv.NewRectangleTopLeft(120, 300, 200, 8),
+		resolv.NewRectangleFromTopLeft(0, 0, 640, 16),
+		resolv.NewRectangleFromTopLeft(0, 360-16, 640, 16),
+		resolv.NewRectangleFromTopLeft(0, 16, 16, 360-16),
+		resolv.NewRectangleFromTopLeft(640-16, 16, 16, 360-16),
+		resolv.NewRectangleFromTopLeft(64, 128, 16, 200),
+		resolv.NewRectangleFromTopLeft(120, 300, 200, 8),
 
 		resolv.NewLine(256-32, 180-32, 256+32, 180+32),
 		resolv.NewLine(256-32, 180+32, 256+32, 180-32),

examples/worldPlatformer.go

@@ -36,18 +36,18 @@ func (w *WorldPlatformer) Init() {
 	solids := resolv.ShapeCollection{
 		resolv.NewCircle(128, 128, 32),
 
-		resolv.NewRectangleTopLeft(0, 0, 640, 8),
-		resolv.NewRectangleTopLeft(640-8, 8, 8, 360-16),
+		resolv.NewRectangleFromTopLeft(0, 0, 640, 8),
+		resolv.NewRectangleFromTopLeft(640-8, 8, 8, 360-16),
 
-		resolv.NewRectangleTopLeft(0, 8, 8, 360-32),
-		resolv.NewRectangleTopLeft(0, 360-8-16, 8, 8),
-		resolv.NewRectangleTopLeft(0, 360-8-8, 8, 8),
+		resolv.NewRectangleFromTopLeft(0, 8, 8, 360-32),
+		resolv.NewRectangleFromTopLeft(0, 360-8-16, 8, 8),
+		resolv.NewRectangleFromTopLeft(0, 360-8-8, 8, 8),
 
-		resolv.NewRectangleTopLeft(64, 200, 300, 8),
-		resolv.NewRectangleTopLeft(64, 280, 300, 8),
-		resolv.NewRectangleTopLeft(512, 96, 32, 200),
+		resolv.NewRectangleFromTopLeft(64, 200, 300, 8),
+		resolv.NewRectangleFromTopLeft(64, 280, 300, 8),
+		resolv.NewRectangleFromTopLeft(512, 96, 32, 200),
 
-		resolv.NewRectangleTopLeft(0, 360-8, 640, 8),
+		resolv.NewRectangleFromTopLeft(0, 360-8, 640, 8),
 	}
 
 	solids.SetTags(TagSolidWall | TagPlatform)
@@ -57,10 +57,10 @@ func (w *WorldPlatformer) Init() {
 	/////
 
 	platforms := resolv.ShapeCollection{
-		resolv.NewRectangleTopLeft(400, 200, 32, 16),
-		resolv.NewRectangleTopLeft(400, 240, 32, 16),
-		resolv.NewRectangleTopLeft(400, 280, 32, 16),
-		resolv.NewRectangleTopLeft(400, 320, 32, 16),
+		resolv.NewRectangleFromTopLeft(400, 200, 32, 16),
+		resolv.NewRectangleFromTopLeft(400, 240, 32, 16),
+		resolv.NewRectangleFromTopLeft(400, 280, 32, 16),
+		resolv.NewRectangleFromTopLeft(400, 320, 32, 16),
 	}
 
 	platforms.SetTags(TagPlatform)
@@ -87,7 +87,7 @@ func (w *WorldPlatformer) Init() {
 	r.SetPositionVec(resolv.NewVector(240, 344))
 	w.space.Add(r)
 
-	w.MovingPlatform = resolv.NewRectangleTopLeft(550, 200, 32, 8)
+	w.MovingPlatform = resolv.NewRectangleFromTopLeft(550, 200, 32, 8)
 	w.MovingPlatform.Tags().Set(TagPlatform)
 	w.space.Add(w.MovingPlatform)
 

shape.go

@@ -79,12 +79,12 @@ func (s *ShapeBase) ID() uint32 {
 	return s.id
 }
 
-// Data returns any auxiliary data set on the Circle shape.
+// Data returns any auxiliary data set on the shape.
 func (s *ShapeBase) Data() any {
 	return s.data
 }
 
-// SetData sets any auxiliary data on the Circle shape.
+// SetData sets any auxiliary data on the shape.
 func (s *ShapeBase) SetData(data any) {
 	s.data = data
 }
@@ -94,7 +94,7 @@ func (s *ShapeBase) Tags() *Tags {
 	return s.tags
 }
 
-// Move translates the Circle by the designated X and Y values.
+// Move translates the Shape by the designated X and Y values.
 func (s *ShapeBase) Move(x, y float64) {
 	s.position.X += x
 	s.position.Y += y

shapefilter.go

@@ -1,5 +1,10 @@
 package resolv
 
+import (
+	"reflect"
+	"sort"
+)
+
 // ShapeIterator is an interface that defines a method to iterate through Shapes.
 // Any object that has such a function (e.g. a ShapeFilter or a ShapeCollection (which is essentially just a slice of Shapes)) fulfills the ShapeIterator interface.
 type ShapeIterator interface {
@@ -22,16 +27,13 @@ func (s ShapeFilter) ForEach(forEachFunc func(shape IShape) bool) {
 
 	s.operatingOn.ForEach(func(shape IShape) bool {
 
-		pass := true
-
 		for _, f := range s.Filters {
 			if !f(shape) {
-				pass = false
 				return true
 			}
 		}
 
-		if pass && !forEachFunc(shape) {
+		if !forEachFunc(shape) {
 			return true
 		}
 
@@ -49,6 +51,15 @@ func (s ShapeFilter) ByTags(tags Tags) ShapeFilter {
 	return s
 }
 
+// NotByTags adds a filter to the ShapeFilter that filters out Shapes by tags (so only Shapes that DO NOT have the specified Tag(s) pass the filter).
+// The function returns the ShapeFiler for easy method chaining.
+func (s ShapeFilter) NotByTags(tags Tags) ShapeFilter {
+	s.Filters = append(s.Filters, func(s IShape) bool {
+		return !s.Tags().Has(tags)
+	})
+	return s
+}
+
 // ByDistance adds a filter to the ShapeFilter that filters out Shapes distance to a given point.
 // The shapes have to be at least min and at most max distance from the given point Vector.
 // The function returns the ShapeFiler for easy method chaining.
@@ -67,6 +78,22 @@ func (s ShapeFilter) ByFunc(filterFunc func(s IShape) bool) ShapeFilter {
 	return s
 }
 
+// ByDataType allows you to filter Shapes by their Data pointer's type. You could use this to, for example, filter out Shapes that have
+// Data objects that are Updatable, where `Updatable` is an interface that has an `Update()` function call.
+// To do this, you would call `s.ByDataType(reflect.TypeFor[Updatable]())`
+func (s ShapeFilter) ByDataType(dataType reflect.Type) ShapeFilter {
+	if dataType == nil {
+		return s
+	}
+	s.Filters = append(s.Filters, func(s IShape) bool {
+		if s.Data() != nil {
+			return reflect.TypeOf(s.Data()).Implements(dataType)
+		}
+		return false
+	})
+	return s
+}
+
 // Not adds a filter to the ShapeFilter that specifcally does not allow specified Shapes in.
 // The function returns the ShapeFiler for easy method chaining.
 func (s ShapeFilter) Not(shapes ...IShape) ShapeFilter {
@@ -86,18 +113,67 @@ func (s ShapeFilter) Shapes() ShapeCollection {
 
 	collection := ShapeCollection{}
 
-	s.operatingOn.ForEach(func(shape IShape) bool {
-		for _, filter := range s.Filters {
-			if filter(shape) {
-				collection = append(collection, shape)
-			}
-		}
+	s.ForEach(func(shape IShape) bool {
+		collection = append(collection, shape)
 		return true
 	})
 
 	return collection
 }
 
+// First returns the first shape that passes the ShapeFilter.
+func (s ShapeFilter) First() IShape {
+	var returnShape IShape
+
+	s.ForEach(func(shape IShape) bool {
+		returnShape = shape
+		return false
+	})
+
+	return returnShape
+}
+
+// Last returns the last shape that passes the ShapeFilter (which means it has to step through all possible options before returning the last one).
+func (s ShapeFilter) Last() IShape {
+	var returnShape IShape
+
+	s.ForEach(func(shape IShape) bool {
+		returnShape = shape
+		return true
+	})
+
+	return returnShape
+}
+
+// First returns the first shape in the ShapeCollection.
+func (s ShapeCollection) First() IShape {
+	if len(s) > 0 {
+		return s[0]
+	}
+	return nil
+}
+
+// Last returns the last shape in the ShapeCollection.
+func (s ShapeCollection) Last() IShape {
+	if len(s) > 0 {
+		return s[len(s)-1]
+	}
+	return nil
+}
+
+// Count returns the number of shapes that pass the filters as a ShapeCollection.
+func (s ShapeFilter) Count() int {
+
+	count := 0
+
+	s.ForEach(func(shape IShape) bool {
+		count++
+		return true
+	})
+
+	return count
+}
+
 // ShapeCollection is a slice of Shapes.
 type ShapeCollection []IShape
 
@@ -123,3 +199,10 @@ func (s ShapeCollection) UnsetTags(tags Tags) {
 		shape.Tags().Unset(tags)
 	}
 }
+
+// SortByDistance sorts the ShapeCollection by distance to the given point.
+func (s ShapeCollection) SortByDistance(point Vector) {
+	sort.Slice(s, func(i, j int) bool {
+		return s[i].Position().DistanceSquared(point) < s[j].Position().DistanceSquared(point)
+	})
+}

space.go

@@ -85,14 +85,14 @@ func (s *Space) RemoveAll() {
 }
 
 // Shapes returns a new slice consisting of all of the shapes present in the Space.
-func (s *Space) Shapes() []IShape {
-	return append(make([]IShape, 0, len(s.shapes)), s.shapes...)
+func (s *Space) Shapes() ShapeCollection {
+	return append(make(ShapeCollection, 0, len(s.shapes)), s.shapes...)
 }
 
-// ForEachShape iterates through each Object in the Space and runs the provided function on them, passing the Shape, its index in the
+// ForEachShape iterates through each shape in the Space and runs the provided function on them, passing the Shape, its index in the
 // Space's shapes slice, and the maximum number of shapes in the space.
 // If the function returns false, the iteration ends. If it returns true, it continues.
-func (s *Space) ForEachShape(forEach func(object IShape, index, maxCount int) bool) {
+func (s *Space) ForEachShape(forEach func(shape IShape, index, maxCount int) bool) {
 
 	for i, o := range s.shapes {
 		if !forEach(o, i, len(s.shapes)) {
@@ -141,13 +141,26 @@ func (s *Space) Cell(cx, cy int) *Cell {
 
 }
 
-// Height returns the height of the Space grid in Cells (so a 320x240 Space with 16x16 cells would have a height of 15).
+// Width returns the spacial width of the Space grid in world coordinates.
+func (s *Space) Width() int {
+	if len(s.cells) > 0 {
+		return len(s.cells[0]) * s.cellWidth
+	}
+	return 0
+}
+
+// Height returns the spacial height of the Space grid in world coordinates.
 func (s *Space) Height() int {
+	return len(s.cells) * s.cellHeight
+}
+
+// HeightInCells returns the height of the Space grid in Cells (so a 320x240 Space with 16x16 cells would have a HeightInCells() of 15).
+func (s *Space) HeightInCells() int {
 	return len(s.cells)
 }
 
-// Width returns the width of the Space grid in Cells (so a 320x240 Space with 16x16 cells would have a width of 20).
-func (s *Space) Width() int {
+// WidthInCells returns the width of the Space grid in Cells (so a 320x240 Space with 16x16 cells would have a WidthInCells() of 20).
+func (s *Space) WidthInCells() int {
 	if len(s.cells) > 0 {
 		return len(s.cells[0])
 	}

utils.go

@@ -112,6 +112,22 @@ func (b Bounds) Height() float64 {
 	return b.Max.Y - b.Min.Y
 }
 
+// MaxAxis returns the maximum value out of either the Bounds's width or height.
+func (b Bounds) MaxAxis() float64 {
+	if b.Width() > b.Height() {
+		return b.Width()
+	}
+	return b.Height()
+}
+
+// MinAxis returns the minimum value out of either the Bounds's width or height.
+func (b Bounds) MinAxis() float64 {
+	if b.Width() > b.Height() {
+		return b.Height()
+	}
+	return b.Width()
+}
+
 // Move moves the Bounds, such that the center point is offset by {x, y}.
 func (b Bounds) Move(x, y float64) Bounds {
 	b.Min.X += x
@@ -141,11 +157,11 @@ func (b Bounds) Intersection(other Bounds) Bounds {
 		return overlap
 	}
 
-	overlap.Min.X = math.Min(other.Max.X, b.Max.X)
-	overlap.Max.X = math.Max(other.Min.X, b.Min.X)
+	overlap.Max.X = math.Min(other.Max.X, b.Max.X)
+	overlap.Min.X = math.Max(other.Min.X, b.Min.X)
 
-	overlap.Min.Y = math.Min(other.Max.Y, b.Max.Y)
-	overlap.Max.Y = math.Max(other.Min.Y, b.Min.Y)
+	overlap.Max.Y = math.Min(other.Max.Y, b.Max.Y)
+	overlap.Min.Y = math.Max(other.Min.Y, b.Min.Y)
 
 	return overlap
 
@@ -341,9 +357,11 @@ func LineTest(settings LineTestSettings) bool {
 	})
 
 	// Loop through all intersections and iterate through them
-	for i, c := range intersectionSets {
-		if !settings.OnIntersect(c, i, len(intersectionSets)) {
-			break
+	if settings.OnIntersect != nil {
+		for i, c := range intersectionSets {
+			if !settings.OnIntersect(c, i, len(intersectionSets)) {
+				break
+			}
 		}
 	}