281 lines
6.9 KiB
Go
281 lines
6.9 KiB
Go
package pixel
|
|
|
|
import (
|
|
"image/color"
|
|
"math"
|
|
)
|
|
|
|
// Sprite is a drawable Picture. It's always anchored by the center of it's Picture.
|
|
type Sprite struct {
|
|
tri *TrianglesData
|
|
bounds Rect
|
|
d Drawer
|
|
}
|
|
|
|
// NewSprite creates a Sprite from the supplied Picture.
|
|
func NewSprite(pic Picture) *Sprite {
|
|
tri := MakeTrianglesData(6)
|
|
s := &Sprite{
|
|
tri: tri,
|
|
d: Drawer{Triangles: tri},
|
|
}
|
|
s.SetPicture(pic)
|
|
return s
|
|
}
|
|
|
|
// SetPicture changes the Sprite's Picture. The new Picture may have a different size, everything
|
|
// works.
|
|
func (s *Sprite) SetPicture(pic Picture) {
|
|
s.d.Picture = pic
|
|
|
|
if s.bounds == pic.Bounds() {
|
|
return
|
|
}
|
|
s.bounds = pic.Bounds()
|
|
|
|
var (
|
|
center = s.bounds.Center()
|
|
horizontal = X(s.bounds.W() / 2)
|
|
vertical = Y(s.bounds.H() / 2)
|
|
)
|
|
|
|
(*s.tri)[0].Position = -horizontal - vertical
|
|
(*s.tri)[1].Position = +horizontal - vertical
|
|
(*s.tri)[2].Position = +horizontal + vertical
|
|
(*s.tri)[3].Position = -horizontal - vertical
|
|
(*s.tri)[4].Position = +horizontal + vertical
|
|
(*s.tri)[5].Position = -horizontal + vertical
|
|
|
|
for i := range *s.tri {
|
|
(*s.tri)[i].Color = NRGBA{1, 1, 1, 1}
|
|
(*s.tri)[i].Picture = center + (*s.tri)[i].Position
|
|
(*s.tri)[i].Intensity = 1
|
|
}
|
|
|
|
s.d.Dirty()
|
|
}
|
|
|
|
// Picture returns the current Sprite's Picture.
|
|
func (s *Sprite) Picture() Picture {
|
|
return s.d.Picture
|
|
}
|
|
|
|
// Draw draws the Sprite onto the provided Target.
|
|
func (s *Sprite) Draw(t Target) {
|
|
s.d.Draw(t)
|
|
}
|
|
|
|
// IMDraw is an immediate-like-mode shape drawer.
|
|
//
|
|
// TODO: mode doc
|
|
type IMDraw struct {
|
|
points []point
|
|
opts point
|
|
matrix Matrix
|
|
mask NRGBA
|
|
tri *TrianglesData
|
|
d Drawer
|
|
tmp []Vec
|
|
}
|
|
|
|
type point struct {
|
|
pos Vec
|
|
col NRGBA
|
|
pic Vec
|
|
in float64
|
|
width float64
|
|
precision int
|
|
endshape EndShape
|
|
}
|
|
|
|
// EndShape specifies the shape of an end of a line or a curve.
|
|
type EndShape int
|
|
|
|
const (
|
|
// SharpEndShape is a square end shape.
|
|
SharpEndShape EndShape = iota
|
|
|
|
// RoundEndShape is a circular end shape.
|
|
RoundEndShape
|
|
)
|
|
|
|
// NewIMDraw creates a new empty IMDraw. An optional Picture can be used to draw with a Picture.
|
|
//
|
|
// If you just want to draw primitive shapes, pass nil as the Picture.
|
|
func NewIMDraw(pic Picture) *IMDraw {
|
|
tri := &TrianglesData{}
|
|
im := &IMDraw{
|
|
tri: tri,
|
|
d: Drawer{Triangles: tri, Picture: pic},
|
|
}
|
|
im.SetMatrix(IM)
|
|
im.SetColorMask(NRGBA{1, 1, 1, 1})
|
|
im.Reset()
|
|
return im
|
|
}
|
|
|
|
// Clear removes all drawn shapes from the IM. This does not remove Pushed points.
|
|
func (imd *IMDraw) Clear() {
|
|
imd.tri.SetLen(0)
|
|
imd.d.Dirty()
|
|
}
|
|
|
|
// Reset restores all point properties to defaults and removes all Pushed points.
|
|
//
|
|
// This does not affect matrix and color mask set by SetMatrix and SetColorMask.
|
|
func (imd *IMDraw) Reset() {
|
|
imd.points = nil
|
|
imd.opts = point{}
|
|
imd.Precision(64)
|
|
}
|
|
|
|
// Draw draws all currently drawn shapes inside the IM onto another Target.
|
|
func (imd *IMDraw) Draw(t Target) {
|
|
imd.d.Draw(t)
|
|
}
|
|
|
|
// Push adds some points to the IM queue. All Pushed points will have the same properties except for
|
|
// the position.
|
|
func (imd *IMDraw) Push(pts ...Vec) {
|
|
point := imd.opts
|
|
for _, pt := range pts {
|
|
point.pos = imd.matrix.Project(pt)
|
|
point.col = imd.mask.Mul(imd.opts.col)
|
|
imd.points = append(imd.points, point)
|
|
}
|
|
}
|
|
|
|
// Color sets the color of the next Pushed points.
|
|
func (imd *IMDraw) Color(color color.Color) {
|
|
imd.opts.col = NRGBAModel.Convert(color).(NRGBA)
|
|
}
|
|
|
|
// Picture sets the Picture coordinates of the next Pushed points.
|
|
func (imd *IMDraw) Picture(pic Vec) {
|
|
imd.opts.pic = pic
|
|
}
|
|
|
|
// Intensity sets the picture Intensity of the next Pushed points.
|
|
func (imd *IMDraw) Intensity(in float64) {
|
|
imd.opts.in = in
|
|
}
|
|
|
|
// Width sets the with property of the next Pushed points.
|
|
//
|
|
// Note that this property does not apply to filled shapes.
|
|
func (imd *IMDraw) Width(w float64) {
|
|
imd.opts.width = w
|
|
}
|
|
|
|
// Precision sets the curve/circle drawing precision of the next Pushed points.
|
|
//
|
|
// It is the number of segments per 360 degrees.
|
|
func (imd *IMDraw) Precision(p int) {
|
|
imd.opts.precision = p
|
|
if p+1 > len(imd.tmp) {
|
|
imd.tmp = append(imd.tmp, make([]Vec, p+1-len(imd.tmp))...)
|
|
}
|
|
if p+1 < len(imd.tmp) {
|
|
imd.tmp = imd.tmp[:p+1]
|
|
}
|
|
}
|
|
|
|
// EndShape sets the endshape of the next Pushed points.
|
|
func (imd *IMDraw) EndShape(es EndShape) {
|
|
imd.opts.endshape = es
|
|
}
|
|
|
|
// SetMatrix sets a Matrix that all further points will be transformed by.
|
|
func (imd *IMDraw) SetMatrix(m Matrix) {
|
|
imd.matrix = m
|
|
}
|
|
|
|
// SetColorMask sets a color that all futher point's color will be multiplied by.
|
|
func (imd *IMDraw) SetColorMask(color color.Color) {
|
|
imd.mask = NRGBAModel.Convert(color).(NRGBA)
|
|
}
|
|
|
|
// FillConvexPolygon takes all points Pushed into the IM's queue and fills the convex polygon formed
|
|
// by them.
|
|
//
|
|
// The polygon does not need to be exactly convex. The way it's drawn is that for each two adjacent
|
|
// points, a triangle is constructed from those two points and the first Pushed point. You can use
|
|
// this property to draw specific concave polygons.
|
|
func (imd *IMDraw) FillConvexPolygon() {
|
|
points := imd.points
|
|
imd.points = nil
|
|
|
|
if len(points) < 3 {
|
|
return
|
|
}
|
|
|
|
i := imd.tri.Len()
|
|
imd.tri.SetLen(imd.tri.Len() + 3*(len(points)-2))
|
|
|
|
for j := 1; j+1 < len(points); j++ {
|
|
(*imd.tri)[i].Position = points[0].pos
|
|
(*imd.tri)[i].Color = points[0].col
|
|
(*imd.tri)[i].Picture = points[0].pic
|
|
(*imd.tri)[i].Intensity = points[0].in
|
|
|
|
(*imd.tri)[i+1].Position = points[j].pos
|
|
(*imd.tri)[i+1].Color = points[j].col
|
|
(*imd.tri)[i+1].Picture = points[j].pic
|
|
(*imd.tri)[i+1].Intensity = points[j].in
|
|
|
|
(*imd.tri)[i+2].Position = points[j+1].pos
|
|
(*imd.tri)[i+2].Color = points[j+1].col
|
|
(*imd.tri)[i+2].Picture = points[j+1].pic
|
|
(*imd.tri)[i+2].Intensity = points[j+1].in
|
|
|
|
i += 3
|
|
}
|
|
|
|
imd.d.Dirty()
|
|
}
|
|
|
|
// FillCircle draws a filled circle around each point in the IM's queue.
|
|
func (imd *IMDraw) FillCircle(radius float64) {
|
|
imd.FillEllipseArc(V(radius, radius), 0, 2*math.Pi)
|
|
}
|
|
|
|
// FillCircleArc draws a filled circle arc around each point in the IM's queue.
|
|
func (imd *IMDraw) FillCircleArc(radius, low, high float64) {
|
|
imd.FillEllipseArc(V(radius, radius), low, high)
|
|
}
|
|
|
|
// FillEllipse draws a filled ellipse around each point in the IM's queue.
|
|
func (imd *IMDraw) FillEllipse(radius Vec) {
|
|
imd.FillEllipseArc(radius, 0, 2*math.Pi)
|
|
}
|
|
|
|
// FillEllipseArc draws a filled ellipse arc around each point in the IM's queue. Low and high
|
|
// angles are in radians.
|
|
func (imd *IMDraw) FillEllipseArc(radius Vec, low, high float64) {
|
|
points := imd.points
|
|
imd.points = nil
|
|
|
|
// normalize high
|
|
if math.Abs(high-low) > 2*math.Pi {
|
|
high = low + math.Mod(high-low, 2*math.Pi)
|
|
}
|
|
|
|
for _, pt := range points {
|
|
imd.Push(pt.pos) // center
|
|
|
|
num := math.Ceil(math.Abs(high-low) / (2 * math.Pi) * float64(pt.precision))
|
|
delta := (high - low) / num
|
|
for i := range imd.tmp[:int(num)+1] {
|
|
angle := low + float64(i)*delta
|
|
sin, cos := math.Sincos(angle)
|
|
imd.tmp[i] = pt.pos + V(
|
|
radius.X()*cos,
|
|
radius.Y()*sin,
|
|
)
|
|
}
|
|
|
|
imd.Push(imd.tmp[:int(num)+1]...)
|
|
imd.FillConvexPolygon()
|
|
}
|
|
}
|