137 lines
2.8 KiB
Go
137 lines
2.8 KiB
Go
package gg
|
|
|
|
import (
|
|
"math"
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
)
|
|
|
|
// Ebitens vector in better abstractions like Vectors.
|
|
type Vertex struct {
|
|
Dst Vector
|
|
Src Vector
|
|
Colority
|
|
}
|
|
|
|
type Triangle [3]Vector
|
|
type Triangles []Triangle
|
|
type DrawableTriangles struct {
|
|
Triangles
|
|
Visibility
|
|
Colority
|
|
ShaderOptions
|
|
ebiten.DrawTrianglesOptions
|
|
}
|
|
|
|
func (v Vertex) Ebiten() ebiten.Vertex {
|
|
return ebiten.Vertex {
|
|
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 := LineSegment{t[0], t[1]}.LenSqr()
|
|
l2 := LineSegment{t[1], t[2]}.LenSqr()
|
|
l3 := LineSegment{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) 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 (ts Triangles) ContainsPoint(p Point) bool {
|
|
for _, t := range ts {
|
|
if t.ContainsPoint(p) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (r *DrawableTriangles) Draw(c *Context) {
|
|
m := c.Camera.RealMatrix()
|
|
|
|
// Draw solid color if no shader.
|
|
if r.Shader == nil {
|
|
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()
|
|
}
|
|
}
|
|
|
|
is := make([]uint16, len(r.Triangles) * 3)
|
|
start := len(c.Engine.vindices)
|
|
for i := 0 ; i < len(is) ; i++ {
|
|
is[i] = uint16(start + i)
|
|
}
|
|
|
|
c.Engine.vertices = append(c.Engine.vertices, vs...)
|
|
c.Engine.vindices = append(c.Engine.vindices, is...)
|
|
|
|
|
|
return
|
|
//c.DrawTriangles(vs, is, img, &r.DrawTrianglesOptions)
|
|
return
|
|
}
|
|
|
|
// Use the Color as base image if no is provided.
|
|
/*if r.Images[0] == nil {
|
|
r.Images[0] = NewImage(1, 1)
|
|
r.Images[0].Set(0, 0, r.Color)
|
|
}
|
|
|
|
w, h := r.Images[0].Size()
|
|
|
|
// Drawing with shader.
|
|
opts := &ebiten.DrawRectShaderOptions{
|
|
GeoM: m,
|
|
Images: r.Images,
|
|
Uniforms: r.Uniforms,
|
|
}
|
|
i.DrawRectShader(w, h, r.Shader, opts)*/
|
|
}
|
|
|