From d424523c63a30b84bb87e4aa01798197fcd8ef45 Mon Sep 17 00:00:00 2001 From: faiface Date: Tue, 14 Mar 2017 13:12:29 +0100 Subject: [PATCH] rename IM -> IMDraw --- graphics.go | 134 ++++++++++++++++++++++++++-------------------------- 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/graphics.go b/graphics.go index a9477a9..f4023a5 100644 --- a/graphics.go +++ b/graphics.go @@ -65,10 +65,10 @@ func (s *Sprite) Draw(t Target) { s.d.Draw(t) } -// IM is an immediate-like-mode shape drawer. +// IMDraw is an immediate-like-mode shape drawer. // // TODO: mode doc -type IM struct { +type IMDraw struct { points []point opts point matrix Matrix @@ -99,12 +99,12 @@ const ( SharpEndShape ) -// NewIM creates a new empty IM. An optional Picture can be used to draw with a Picture. +// 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 NewIM(pic Picture) *IM { +func NewIMDraw(pic Picture) *IMDraw { tri := &TrianglesData{} - im := &IM{ + im := &IMDraw{ tri: tri, d: Drawer{Triangles: tri, Picture: pic}, } @@ -115,132 +115,132 @@ func NewIM(pic Picture) *IM { } // Clear removes all drawn shapes from the IM. This does not remove Pushed points. -func (im *IM) Clear() { - im.tri.SetLen(0) - im.d.Dirty() +func (imd *IMDraw) Clear() { + imd.tri.SetLen(0) + imd.d.Dirty() } // Draw draws all currently drawn shapes inside the IM onto another Target. -func (im *IM) Draw(t Target) { - im.d.Draw(t) +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 (im *IM) Push(pts ...Vec) { - point := im.opts +func (imd *IMDraw) Push(pts ...Vec) { + point := imd.opts for _, pt := range pts { - point.pos = im.matrix.Project(pt) - point.col = im.mask.Mul(im.opts.col) - im.points = append(im.points, point) + 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 (im *IM) Color(color color.Color) { - im.opts.col = NRGBAModel.Convert(color).(NRGBA) +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 (im *IM) Picture(pic Vec) { - im.opts.pic = pic +func (imd *IMDraw) Picture(pic Vec) { + imd.opts.pic = pic } // Intensity sets the picture Intensity of the next Pushed points. -func (im *IM) Intensity(in float64) { - im.opts.in = in +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 (im *IM) Width(w float64) { - im.opts.width = w +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 (im *IM) Precision(p int) { - im.opts.precision = p - if p+1 > len(im.tmp) { - im.tmp = append(im.tmp, make([]Vec, p+1-len(im.tmp))...) +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(im.tmp) { - im.tmp = im.tmp[:p+1] + if p+1 < len(imd.tmp) { + imd.tmp = imd.tmp[:p+1] } } // EndShape sets the endshape of the next Pushed points. -func (im *IM) EndShape(es EndShape) { - im.opts.endshape = es +func (imd *IMDraw) EndShape(es EndShape) { + imd.opts.endshape = es } // SetMatrix sets a Matrix that all further points will be transformed by. -func (im *IM) SetMatrix(m Matrix) { - im.matrix = m +func (imd *IMDraw) SetMatrix(m Matrix) { + imd.matrix = m } // SetColorMask sets a color that all futher point's color will be multiplied by. -func (im *IM) SetColorMask(color color.Color) { - im.mask = NRGBAModel.Convert(color).(NRGBA) +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. -func (im *IM) FillConvexPolygon() { - points := im.points - im.points = nil +func (imd *IMDraw) FillConvexPolygon() { + points := imd.points + imd.points = nil if len(points) < 3 { return } - i := im.tri.Len() - im.tri.SetLen(im.tri.Len() + 3*(len(points)-2)) + i := imd.tri.Len() + imd.tri.SetLen(imd.tri.Len() + 3*(len(points)-2)) for j := 1; j+1 < len(points); j++ { - (*im.tri)[i].Position = points[0].pos - (*im.tri)[i].Color = points[0].col - (*im.tri)[i].Picture = points[0].pic - (*im.tri)[i].Intensity = points[0].in + (*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 - (*im.tri)[i+1].Position = points[j].pos - (*im.tri)[i+1].Color = points[j].col - (*im.tri)[i+1].Picture = points[j].pic - (*im.tri)[i+1].Intensity = points[j].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 - (*im.tri)[i+2].Position = points[j+1].pos - (*im.tri)[i+2].Color = points[j+1].col - (*im.tri)[i+2].Picture = points[j+1].pic - (*im.tri)[i+2].Intensity = points[j+1].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 } - im.d.Dirty() + imd.d.Dirty() } // FillCircle draws a filled circle around each point in the IM's queue. -func (im *IM) FillCircle(radius float64) { - im.FillEllipseArc(V(radius, radius), 0, 2*math.Pi) +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 (im *IM) FillCircleArc(radius, low, high float64) { - im.FillEllipseArc(V(radius, radius), low, high) +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 (im *IM) FillEllipse(radius Vec) { - im.FillEllipseArc(radius, 0, 2*math.Pi) +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 (im *IM) FillEllipseArc(radius Vec, low, high float64) { - points := im.points - im.points = nil +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 { @@ -248,20 +248,20 @@ func (im *IM) FillEllipseArc(radius Vec, low, high float64) { } for _, pt := range points { - im.Push(pt.pos) // center + 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 im.tmp[:int(num)+1] { + for i := range imd.tmp[:int(num)+1] { angle := low + float64(i)*delta sin, cos := math.Sincos(angle) - im.tmp[i] = pt.pos + V( + imd.tmp[i] = pt.pos + V( radius.X()*cos, radius.Y()*sin, ) } - im.Push(im.tmp[:int(num)+1]...) - im.FillConvexPolygon() + imd.Push(imd.tmp[:int(num)+1]...) + imd.FillConvexPolygon() } }