Questions regarding MTV and Shapes

[d3rped]

First of all thanks for writing and maintaining such a great library.

Whilst familiarizing myself with it I ran into a few issues.
1.
Either I'm not understanding how to use the MTV from intersections or it is a bug.
Depending on the actual overlap the normal can point in the opposite direction that it should.


Here is the code for the collision example.

package main

import (
	"fmt"
	_ "embed"
	"image/color"
	"log"
	"math"

	"github.com/golang/freetype/truetype"
	"github.com/hajimehoshi/ebiten/v2"
	"github.com/hajimehoshi/ebiten/v2/text"
	"github.com/hajimehoshi/ebiten/v2/vector"
	"github.com/solarlune/resolv"
	"golang.org/x/image/font"
)

//go:embed excel.ttf
var excelFont []byte

type Game struct {
	Shapes   [2]*resolv.ConvexPolygon
	Screen   *ebiten.Image
	Redraw   bool
	FontFace font.Face
}

func (g *Game) Update() error {
	if ebiten.IsKeyPressed(ebiten.KeyW) {
		g.Redraw = true
		g.Shapes[1].Move(0, -1)
	}
	if ebiten.IsKeyPressed(ebiten.KeyS) {
		g.Redraw = true
		g.Shapes[1].Move(0, 1)
	}
	if ebiten.IsKeyPressed(ebiten.KeyA) {
		g.Redraw = true
		g.Shapes[1].Move(-1, 0)
	}
	if ebiten.IsKeyPressed(ebiten.KeyD) {
		g.Redraw = true
		g.Shapes[1].Move(1, 0)
	}
	if ebiten.IsKeyPressed(ebiten.KeyQ) {
		g.Redraw = true
		g.Shapes[1].Rotate(-5 * math.Pi / 360)
	}
	if ebiten.IsKeyPressed(ebiten.KeyE) {
		g.Redraw = true
		g.Shapes[1].Rotate(5 * math.Pi / 360)
	}
	return nil
}

func (g *Game) Draw(screen *ebiten.Image) {
	if g.Redraw {
		g.Screen.Clear()
		drawPolygon(g.Screen, g.Shapes[0])
		drawPolygon(g.Screen, g.Shapes[1])

		if intersection := g.Shapes[1].Intersection(0, 0, g.Shapes[0]); intersection != nil {
			for _, point := range intersection.Points {
				vector.DrawFilledCircle(g.Screen, float32(point.X), float32(point.Y), 2, color.RGBA{255, 0, 0, 255}, false)
			}
			mtv := intersection.MTV
			g.DrawText(g.Screen, 16, 16, fmt.Sprintf("ResX: %f", mtv.X),	fmt.Sprintf("ResY: %f", mtv.Y))
		}

		g.Redraw = false
	}
	screen.DrawImage(g.Screen, &ebiten.DrawImageOptions{})
}

func (g *Game) DrawText(screen *ebiten.Image, x, y int, textLines ...string) {
	rectHeight := 10
	for _, txt := range textLines {
		w := float64(font.MeasureString(g.FontFace, txt).Round())
		vector.DrawFilledRect(screen, float32(x), float32(y-8), float32(w), float32(rectHeight), color.RGBA{0, 0, 0, 192}, false)

		text.Draw(g.Screen, txt, g.FontFace, x+1, y+1, color.RGBA{0, 0, 150, 255})
		text.Draw(g.Screen, txt, g.FontFace, x, y, color.RGBA{100, 150, 255, 255})
		y += rectHeight
	}
}

func (g *Game) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
	return 140, 140
}

func main() {
	ebiten.SetWindowSize(140, 140)
	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
	ebiten.SetWindowTitle("Test")

	game := Game{}
	game.Shapes[0] = resolv.NewRectangle(20, 60, 100, 40)
	game.Shapes[1] = resolv.NewConvexPolygon(70, 105, -10, -10, 10, -10, 10, 10, -10, 10)
	game.Screen = ebiten.NewImage(140, 140)
	game.Redraw = true
	fontData, _ := truetype.Parse(excelFont)
	opts := &truetype.Options{
          Size:    10,
          DPI:     72,
          Hinting: font.HintingFull,
      }
	game.FontFace = truetype.NewFace(fontData, opts)

	if err := ebiten.RunGame(&game); err != nil {
		log.Fatal(err)
	}
}

func drawPolygon(screen *ebiten.Image, poly *resolv.ConvexPolygon) {
	for _, line := range poly.Lines() {
		vector.StrokeLine(screen, float32(line.Start.X), float32(line.Start.Y), float32(line.End.X), float32(line.End.Y), 1, color.RGBA{255, 255, 255, 255}, false)
	}
}

Another issue I had is attaching a shape, which rotates around its center, to an Object. (actually an issue for any attached rotating shape)

const tileSize float64 = 32
// Object that would be axis alligned for AABB collision checks
object := resolv.NewObject(0, 0, 2*tileSize, 2*tileSize, "solid")
// Shape that can rotate around its center and can fit into object (independent of its rotation)
shape := resolv.NewConvexPolygon(
	tileSize, tileSize,
	-tileSize/2, -tileSize/2,
	tileSize/2, -tileSize/2,
	tileSize/2, tileSize/2,
	-tileSize/2, tileSize/2,
)
// Adding the shape to the object calls the update method 
// and overrides the shapes position to that of the object 
// -> the shape pokes out of the objects bounding box and is missalligned
object.SetShape(shape)

Thanks a lot in advance.
My current solution is to have the shape and object separated inside a struct and to update them separately.
Is there really no way to attach a shape with a relative position?