144 lines
2.8 KiB
Go
144 lines
2.8 KiB
Go
package gg
|
|
|
|
import (
|
|
"math"
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
)
|
|
|
|
type EVertex = ebiten.Vertex
|
|
|
|
// Ebitens vector in better abstractions like Vectors.
|
|
type Vertex struct {
|
|
Dst Vector
|
|
Src Vector
|
|
Colority
|
|
}
|
|
|
|
type Triangle [3]Vector
|
|
type DrawableTriangles struct {
|
|
Triangles
|
|
Colority
|
|
}
|
|
|
|
func (v Vertex) Ebiten() EVertex {
|
|
return EVertex {
|
|
DstX: float32(v.Dst.X),
|
|
DstY: float32(v.Dst.Y),
|
|
SrcX: float32(v.Src.X),
|
|
SrcY: float32(v.Src.Y),
|
|
ColorR: float32(v.Color.R)/(float32(MaxColorV)),
|
|
ColorG: float32(v.Color.G)/(float32(MaxColorV)),
|
|
ColorB: float32(v.Color.B)/(float32(MaxColorV)),
|
|
ColorA: float32(v.Color.A)/(float32(MaxColorV)),
|
|
}
|
|
}
|
|
|
|
// Returns the area of the triangle.
|
|
func (t Triangle) Area() Float {
|
|
x1 := t[0].X
|
|
y1 := t[0].Y
|
|
|
|
x2 := t[1].X
|
|
y2 := t[1].Y
|
|
|
|
x3 := t[2].X
|
|
y3 := t[2].Y
|
|
|
|
return math.Abs( (x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2))/2)
|
|
}
|
|
func sqr(v Float) Float {
|
|
return v * v
|
|
}
|
|
// Return squares of lengths of sides of the triangle.
|
|
func (t Triangle) SideLengthSquares() ([3]Float) {
|
|
|
|
l1 := Edge{t[0], t[1]}.LenSqr()
|
|
l2 := Edge{t[1], t[2]}.LenSqr()
|
|
l3 := Edge{t[2], t[0]}.LenSqr()
|
|
|
|
return [3]Float{l1, l2, l3}
|
|
}
|
|
|
|
// Check whether the point is in the triangle.
|
|
func (t Triangle) ContainsPoint(p Point) bool {
|
|
d1 := Triangle{p, t[0], t[1]}.Sgn()
|
|
d2 := Triangle{p, t[1], t[2]}.Sgn()
|
|
d3 := Triangle{p, t[2], t[0]}.Sgn()
|
|
|
|
neg := (d1 < 0) || (d2 < 0) || (d3 < 0)
|
|
pos := (d1 > 0) || (d2 > 0) || (d3 > 0)
|
|
|
|
return !(neg && pos)
|
|
}
|
|
|
|
func (t Triangle) ContainedPoints(pts Points) []Point {
|
|
ret := []Point{}
|
|
for i := range pts {
|
|
if t.ContainsPoint(pts[i]) {
|
|
ret = append(ret, pts[i])
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (t Triangle) Sgn() Float {
|
|
return (t[0].X - t[2].X) * (t[1].Y - t[2].Y) -
|
|
(t[1].X - t[2].X) * (t[0].Y - t[2].Y)
|
|
}
|
|
|
|
func (t Triangle) Edges() Edges {
|
|
return Edges{
|
|
Edge{t[0], t[1]},
|
|
Edge{t[1], t[2]},
|
|
Edge{t[2], t[0]},
|
|
}
|
|
}
|
|
|
|
func (t Triangle) Vertices() Vertices {
|
|
return Vertices{
|
|
t[0], t[1], t[2],
|
|
}
|
|
}
|
|
type Triangles []Triangle
|
|
|
|
func (ts Triangles) ContainedPoints(pts Points) (Points) {
|
|
ret := []Point{}
|
|
for _, t := range ts {
|
|
ps := t.ContainedPoints(pts)
|
|
ret = append(ret, ps...)
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (ts Triangles) Vertices() Vertices {
|
|
ret := make(Vertices, 0, len(ts)*3)
|
|
for _, t := range ts {
|
|
ret = append(ret, t.Vertices()...)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (ts Triangles) Edges() Edges {
|
|
ret := make(Edges, 0, len(ts)*3)
|
|
for _, t := range ts {
|
|
ret = append(ret, t.Edges()...)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (r *DrawableTriangles) MakeEVertices(c *Context) []EVertex {
|
|
m := c.Camera.RealMatrix()
|
|
vs := make([]ebiten.Vertex, len(r.Triangles) * 3)
|
|
var buf Vertex
|
|
buf.Color = r.Color
|
|
for i := range r.Triangles {
|
|
for j := range r.Triangles[i] {
|
|
buf.Dst = r.Triangles[i][j].Apply(m)
|
|
vs[i*3 + j] = buf.Ebiten()
|
|
}
|
|
}
|
|
return vs
|
|
}
|
|
|
|
|