From 4427206988bb2b1ee57621e4e8d5a89f5dd3d74c Mon Sep 17 00:00:00 2001
From: faiface <faiface@ksp.sk>
Date: Wed, 14 Dec 2016 17:53:29 +0100
Subject: [PATCH] add general Shape and embed it in specific shapes
---
graphics.go | 406 +++++++++++++++++-----------------------------------
1 file changed, 133 insertions(+), 273 deletions(-)
diff --git a/graphics.go b/graphics.go
index 886a507..b0485bb 100644
--- a/graphics.go
+++ b/graphics.go
@@ -85,111 +85,73 @@ func (g *Group) Do(sub func(pixelgl.Context)) {
sub(g.context)
}
-// Sprite is a picture that can be drawn on the screen. Optionally it can be color masked or tranformed.
+// Shape is a general drawable shape constructed from vertices.
//
-// Usually, you only transform objects when you're drawing them (by passing transforms to the Draw method).
-// With sprites however, it can be useful to also transform them "statically". For example, sprites are
-// anchor by their bottom-left corner by default. Setting a transform can change this anchor to the center,
-// or wherever you want.
-type Sprite struct {
+// Vertices are specified in the vertex array of a shape. A shape can have a picture, a color (mask) and a static
+// transform.
+//
+// Usually you use this type only indirectly throught other specific shapes (sprites, polygons, ...) embedding it.
+type Shape struct {
parent pixelgl.Doer
- color color.Color
picture Picture
+ color color.Color
transform Transform
va *pixelgl.VertexArray
}
-// NewSprite creates a new sprite with the supplied picture. The sprite's size is the size of the supplied picture.
-// If you want to change the sprite's size, change it's transform.
-func NewSprite(parent pixelgl.Doer, picture Picture) *Sprite {
- s := &Sprite{
+// NewShape creates a new shape with specified parent, picture, color, transform and vertex array.
+func NewShape(parent pixelgl.Doer, picture Picture, c color.Color, transform Transform, va *pixelgl.VertexArray) *Shape {
+ return &Shape{
parent: parent,
- color: color.White,
picture: picture,
- transform: Position(0),
- }
-
- parent.Do(func(ctx pixelgl.Context) {
- var err error
- s.va, err = pixelgl.NewVertexArray(
- picture.Texture(),
- ctx.Shader().VertexFormat(),
- pixelgl.DynamicUsage,
- 4,
- []int{0, 1, 2, 0, 2, 3},
- )
- if err != nil {
- panic(errors.Wrap(err, "failed to create sprite"))
- }
- })
-
- w, h := picture.Bounds().Size.XY()
- for i, p := range []Vec{V(0, 0), V(w, 0), V(w, h), V(0, h)} {
- texCoord := V(
- (picture.Bounds().X()+p.X())/float64(picture.Texture().Width()),
- (picture.Bounds().Y()+p.Y())/float64(picture.Texture().Height()),
- )
-
- s.va.SetVertexAttributeVec2(
- i,
- pixelgl.Position,
- mgl32.Vec2{
- float32(p.X()),
- float32(p.Y()),
- },
- )
- s.va.SetVertexAttributeVec4(i, pixelgl.Color, mgl32.Vec4{1, 1, 1, 1})
- s.va.SetVertexAttributeVec2(
- i,
- pixelgl.TexCoord,
- mgl32.Vec2{
- float32(texCoord.X()),
- float32(texCoord.Y()),
- },
- )
+ color: c,
+ transform: transform,
+ va: va,
}
-
- return s
}
-// Delete deletes a sprite. Note, that this does not delete it's picture.
-func (s *Sprite) Delete() {
+// Delete deletes the underlying
+func (s *Shape) Delete() {
s.va.Delete()
}
-// Picture returns the sprite's picture.
-func (s *Sprite) Picture() Picture {
+// SetPicture changes the picture of a shape.
+func (s *Shape) SetPicture(picture Picture) {
+ s.picture = picture
+}
+
+// Picture returns the current picture of a shape.
+func (s *Shape) Picture() Picture {
return s.picture
}
-// SetColor sets a mask color of a sprite.
-func (s *Sprite) SetColor(c color.Color) {
+// SetColor changes the color (mask) of a shape.
+func (s *Shape) SetColor(c color.Color) {
s.color = c
}
-// Color returns the mask color of a sprite. Default is white.
-func (s *Sprite) Color() color.Color {
+// Color returns the current color (mask) of a shape.
+func (s *Shape) Color() color.Color {
return s.color
}
-// SetTransform sets a "static" transform of a sprite. Setting a transform is equivalent to passing
-// the transform as the last parameter to Draw.
-//
-// sprite.SetTransform(transform)
-// sprite.Draw(camera)
-// // same as below
-// sprite.Draw(camera, tranform)
-func (s *Sprite) SetTransform(t Transform) {
- s.transform = t
+// SetTransform changes the ("static") transform of a shape.
+func (s *Shape) SetTransform(transform Transform) {
+ s.transform = transform
}
-// Transform returns the static transform of a sprite.
-func (s *Sprite) Transform() Transform {
+// Transform returns the current ("static") transform of a shape.
+func (s *Shape) Transform() Transform {
return s.transform
}
+// VertexArray changes the underlying vertex array of a shape.
+func (s *Shape) VertexArray() *pixelgl.VertexArray {
+ return s.va
+}
+
// Draw draws a sprite transformed by the supplied transforms applied in the reverse order.
-func (s *Sprite) Draw(t ...Transform) {
+func (s *Shape) Draw(t ...Transform) {
mat := mgl32.Ident3()
for i := range t {
mat = mat.Mul3(t[i].Mat3())
@@ -198,36 +160,78 @@ func (s *Sprite) Draw(t ...Transform) {
s.parent.Do(func(ctx pixelgl.Context) {
r, g, b, a := colorToRGBA(s.color)
- ctx.Shader().SetUniformVec4(pixelgl.MaskColor, mgl32.Vec4{r, g, b, a})
- ctx.Shader().SetUniformMat3(pixelgl.Transform, mat)
+ ctx.Shader().SetUniformAttr(maskColorVec4, mgl32.Vec4{r, g, b, a})
+ ctx.Shader().SetUniformAttr(transformMat3, mat)
+
+ if s.picture.Texture() != nil {
+ s.picture.Texture().Do(func(pixelgl.Context) {
+ s.va.Draw()
+ })
+ } else {
+ s.va.Draw()
+ }
+ })
+}
+
+// Sprite is a picture that can be drawn on the screen. Optionally it can be color masked or tranformed.
+//
+// Usually, you only transform objects when you're drawing them (by passing transforms to the Draw method).
+// With sprites however, it can be useful to also transform them "statically". For example, sprites are
+// anchor by their bottom-left corner by default. Setting a transform can change this anchor to the center,
+// or wherever you want.
+type Sprite struct {
+ *Shape
+}
- s.va.Draw()
+// NewSprite creates a new sprite with the supplied picture. The sprite's size is the size of the supplied picture.
+// If you want to change the sprite's size, change it's transform.
+func NewSprite(parent pixelgl.Doer, picture Picture) *Sprite {
+ var va *pixelgl.VertexArray
+
+ parent.Do(func(ctx pixelgl.Context) {
+ var err error
+ va, err = pixelgl.NewVertexArray(
+ picture.Texture(),
+ ctx.Shader().VertexFormat(),
+ pixelgl.DynamicUsage,
+ 4,
+ []int{0, 1, 2, 0, 2, 3},
+ )
+ if err != nil {
+ panic(errors.Wrap(err, "failed to create sprite"))
+ }
})
+
+ w, h := picture.Bounds().Size.XY()
+ for i, p := range []Vec{V(0, 0), V(w, 0), V(w, h), V(0, h)} {
+ texCoord := V(
+ (picture.Bounds().X()+p.X())/float64(picture.Texture().Width()),
+ (picture.Bounds().Y()+p.Y())/float64(picture.Texture().Height()),
+ )
+
+ va.SetVertexAttr(i, positionVec2, mgl32.Vec2{float32(p.X()), float32(p.Y())})
+ va.SetVertexAttr(i, colorVec4, mgl32.Vec4{1, 1, 1, 1})
+ va.SetVertexAttr(i, texCoordVec2, mgl32.Vec2{float32(texCoord.X()), float32(texCoord.Y())})
+ }
+
+ return &Sprite{NewShape(parent, picture, color.White, Position(0), va)}
}
// LineColor a line shape (with sharp ends) filled with a single color.
type LineColor struct {
- parent pixelgl.Doer
- color color.Color
- a, b Vec
- width float64
- va *pixelgl.VertexArray
+ *Shape
+ a, b Vec
+ width float64
}
// NewLineColor creates a new line shape between points A and B filled with a single color. Parent is an object
// that this shape belongs to, such as a window, or a graphics effect.
func NewLineColor(parent pixelgl.Doer, c color.Color, a, b Vec, width float64) *LineColor {
- lc := &LineColor{
- parent: parent,
- color: c,
- a: a,
- b: b,
- width: width,
- }
+ var va *pixelgl.VertexArray
parent.Do(func(ctx pixelgl.Context) {
var err error
- lc.va, err = pixelgl.NewVertexArray(
+ va, err = pixelgl.NewVertexArray(
parent,
ctx.Shader().VertexFormat(),
pixelgl.DynamicUsage,
@@ -240,12 +244,12 @@ func NewLineColor(parent pixelgl.Doer, c color.Color, a, b Vec, width float64) *
})
for i := 0; i < 4; i++ {
- lc.va.SetVertexAttributeVec4(i, pixelgl.Color, mgl32.Vec4{1, 1, 1, 1})
- lc.va.SetVertexAttributeVec2(i, pixelgl.TexCoord, mgl32.Vec2{-1, -1})
+ va.SetVertexAttr(i, colorVec4, mgl32.Vec4{1, 1, 1, 1})
+ va.SetVertexAttr(i, texCoordVec2, mgl32.Vec2{-1, -1})
}
+ lc := &LineColor{NewShape(parent, Picture{}, c, Position(0), va), a, b, width}
lc.setPoints()
-
return lc
}
@@ -253,20 +257,10 @@ func NewLineColor(parent pixelgl.Doer, c color.Color, a, b Vec, width float64) *
func (lc *LineColor) setPoints() {
r := (lc.b - lc.a).Unit().Scaled(lc.width / 2).Rotated(math.Pi / 2)
for i, p := range []Vec{lc.a - r, lc.a + r, lc.b - r, lc.b + r} {
- lc.va.SetVertexAttributeVec2(i, pixelgl.Position, mgl32.Vec2{float32(p.X()), float32(p.Y())})
+ lc.va.SetVertexAttr(i, positionVec2, mgl32.Vec2{float32(p.X()), float32(p.Y())})
}
}
-// SetColor changes the color of a line.
-func (lc *LineColor) SetColor(c color.Color) {
- lc.color = c
-}
-
-// Color returns the current color of a line.
-func (lc *LineColor) Color() color.Color {
- return lc.color
-}
-
// SetA changes the position of the first endpoint of a line.
func (lc *LineColor) SetA(a Vec) {
lc.a = a
@@ -300,43 +294,16 @@ func (lc *LineColor) Width() float64 {
return lc.width
}
-// Draw draws a line transformed by the supplied transforms applied in the reverse order.
-func (lc *LineColor) Draw(t ...Transform) {
- mat := mgl32.Ident3()
- for i := range t {
- mat = mat.Mul3(t[i].Mat3())
- }
-
- lc.parent.Do(func(ctx pixelgl.Context) {
- r, g, b, a := colorToRGBA(lc.color)
- ctx.Shader().SetUniformVec4(pixelgl.MaskColor, mgl32.Vec4{r, g, b, a})
- ctx.Shader().SetUniformMat3(pixelgl.Transform, mat)
- })
-
- lc.va.Draw()
-}
-
-// Delete destroys a line shape and releases it's video memory. Do not use this shape after calling Delete.
-func (lc *LineColor) Delete() {
- lc.va.Delete()
-}
-
-// PolygonColor is a polygon shape filled with a single color.
+// PolygonColor is a convex polygon shape filled with a single color.
type PolygonColor struct {
- parent pixelgl.Doer
- color color.Color
+ *Shape
points []Vec
- va *pixelgl.VertexArray
}
// NewPolygonColor creates a new polygon shape filled with a single color. Parent is an object that this shape belongs to,
// such as a window, or a graphics effect.
func NewPolygonColor(parent pixelgl.Doer, c color.Color, points ...Vec) *PolygonColor {
- pc := &PolygonColor{
- parent: parent,
- color: c,
- points: points,
- }
+ var va *pixelgl.VertexArray
var indices []int
for i := 2; i < len(points); i++ {
@@ -345,7 +312,7 @@ func NewPolygonColor(parent pixelgl.Doer, c color.Color, points ...Vec) *Polygon
parent.Do(func(ctx pixelgl.Context) {
var err error
- pc.va, err = pixelgl.NewVertexArray(
+ va, err = pixelgl.NewVertexArray(
parent,
ctx.Shader().VertexFormat(),
pixelgl.DynamicUsage,
@@ -358,50 +325,25 @@ func NewPolygonColor(parent pixelgl.Doer, c color.Color, points ...Vec) *Polygon
})
for i, p := range points {
- pc.va.SetVertexAttributeVec2(
- i,
- pixelgl.Position,
- mgl32.Vec2{
- float32(p.X()),
- float32(p.Y()),
- },
- )
- pc.va.SetVertexAttributeVec4(
- i,
- pixelgl.Color,
- mgl32.Vec4{1, 1, 1, 1},
- )
- pc.va.SetVertexAttributeVec2(
- i,
- pixelgl.TexCoord,
- mgl32.Vec2{-1, -1},
- )
+ va.SetVertexAttr(i, positionVec2, mgl32.Vec2{float32(p.X()), float32(p.Y())})
+ va.SetVertexAttr(i, colorVec4, mgl32.Vec4{1, 1, 1, 1})
+ va.SetVertexAttr(i, texCoordVec2, mgl32.Vec2{-1, -1})
}
- return pc
+ return &PolygonColor{NewShape(parent, Picture{}, c, Position(0), va), points}
}
-// Count returns the number of points in a polygon.
-func (pc *PolygonColor) Count() int {
+// PointNum returns the number of points in a polygon.
+func (pc *PolygonColor) PointNum() int {
return len(pc.points)
}
-// SetColor changes the color of a polygon to c.
-func (pc *PolygonColor) SetColor(c color.Color) {
- pc.color = c
-}
-
-// Color returns the current color of a polygon.
-func (pc *PolygonColor) Color() color.Color {
- return pc.color
-}
-
// SetPoint changes the position of a point in a polygon.
//
// If the index is out of range, this function panics.
func (pc *PolygonColor) SetPoint(i int, point Vec) {
pc.points[i] = point
- pc.va.SetVertexAttributeVec2(i, pixelgl.Position, mgl32.Vec2{float32(point.X()), float32(point.Y())})
+ pc.va.SetVertexAttr(i, positionVec2, mgl32.Vec2{float32(point.X()), float32(point.Y())})
}
// Point returns the position of a point in a polygon.
@@ -411,34 +353,11 @@ func (pc *PolygonColor) Point(i int) Vec {
return pc.points[i]
}
-// Draw draws a polygon transformed by the supplied transforms applied in the reverse order.
-func (pc *PolygonColor) Draw(t ...Transform) {
- mat := mgl32.Ident3()
- for i := range t {
- mat = mat.Mul3(t[i].Mat3())
- }
-
- pc.parent.Do(func(ctx pixelgl.Context) {
- r, g, b, a := colorToRGBA(pc.color)
- ctx.Shader().SetUniformVec4(pixelgl.MaskColor, mgl32.Vec4{r, g, b, a})
- ctx.Shader().SetUniformMat3(pixelgl.Transform, mat)
- })
-
- pc.va.Draw()
-}
-
-// Delete destroys a polygon shape and releases it's video memory. Do not use this shape after calling Delete.
-func (pc *PolygonColor) Delete() {
- pc.va.Delete()
-}
-
// EllipseColor is an ellipse shape filled with a single color.
type EllipseColor struct {
- parent pixelgl.Doer
- color color.Color
+ *Shape
radius Vec
fill float64
- va *pixelgl.VertexArray
}
// NewEllipseColor creates a new ellipse shape filled with a single color. Parent is an object that this shape belongs to,
@@ -446,14 +365,9 @@ type EllipseColor struct {
// be filled (from the outside). The value of 1 means that the whole ellipse is filled. The value of 0 means that none of the
// ellipse is filled (which makes the ellipse invisible).
func NewEllipseColor(parent pixelgl.Doer, c color.Color, radius Vec, fill float64) *EllipseColor {
- const n = 256
+ var va *pixelgl.VertexArray
- ec := &EllipseColor{
- parent: parent,
- color: c,
- radius: radius,
- fill: fill,
- }
+ const n = 256
var indices []int
for i := 2; i < (n+1)*2; i++ {
@@ -462,7 +376,7 @@ func NewEllipseColor(parent pixelgl.Doer, c color.Color, radius Vec, fill float6
parent.Do(func(ctx pixelgl.Context) {
var err error
- ec.va, err = pixelgl.NewVertexArray(
+ va, err = pixelgl.NewVertexArray(
parent,
ctx.Shader().VertexFormat(),
pixelgl.DynamicUsage,
@@ -477,85 +391,31 @@ func NewEllipseColor(parent pixelgl.Doer, c color.Color, radius Vec, fill float6
for k := 0; k < n+1; k++ {
i, j := k*2, k*2+1
angle := math.Pi * 2 * float64(k%n) / n
- ec.va.SetVertexAttributeVec2(
- i,
- pixelgl.Position,
- mgl32.Vec2{
- float32(math.Cos(angle)),
- float32(math.Sin(angle)),
- },
- )
- ec.va.SetVertexAttributeVec4(
- i,
- pixelgl.Color,
- mgl32.Vec4{1, 1, 1, 1},
- )
- ec.va.SetVertexAttributeVec2(
- i,
- pixelgl.TexCoord,
- mgl32.Vec2{-1, -1},
- )
- ec.va.SetVertexAttributeVec2(
- j,
- pixelgl.Position,
- mgl32.Vec2{
- float32(math.Cos(angle) * (1 - fill)),
- float32(math.Sin(angle) * (1 - fill)),
- },
- )
- ec.va.SetVertexAttributeVec4(
- j,
- pixelgl.Color,
- mgl32.Vec4{1, 1, 1, 1},
- )
- ec.va.SetVertexAttributeVec2(
- j,
- pixelgl.TexCoord,
- mgl32.Vec2{-1, -1},
- )
- }
- return ec
-}
-
-// SetColor changes the color of an ellipse.
-func (ec *EllipseColor) SetColor(c color.Color) {
- ec.color = c
-}
-
-// Color returns the current color of an ellipse.
-func (ec *EllipseColor) Color() color.Color {
- return ec.color
-}
+ va.SetVertexAttr(i, positionVec2, mgl32.Vec2{
+ float32(math.Cos(angle) * radius.X()),
+ float32(math.Sin(angle) * radius.Y()),
+ })
+ va.SetVertexAttr(i, colorVec4, mgl32.Vec4{1, 1, 1, 1})
+ va.SetVertexAttr(i, texCoordVec2, mgl32.Vec2{-1, -1})
+
+ va.SetVertexAttr(j, positionVec2, mgl32.Vec2{
+ float32(math.Cos(angle) * radius.X() * (1 - fill)),
+ float32(math.Sin(angle) * radius.Y() * (1 - fill)),
+ })
+ va.SetVertexAttr(j, colorVec4, mgl32.Vec4{1, 1, 1, 1})
+ va.SetVertexAttr(j, texCoordVec2, mgl32.Vec2{-1, -1})
+ }
-// SetRadius sets the radius (which can be different in X and Y axis) of an ellipse.
-func (ec *EllipseColor) SetRadius(radius Vec) {
- ec.radius = radius
+ return &EllipseColor{NewShape(parent, Picture{}, c, Position(0), va), radius, fill}
}
-// Radius returns the current radius of an ellipse.
+// Radius returns the radius of an ellipse.
func (ec *EllipseColor) Radius() Vec {
return ec.radius
}
-// Draw dras an ellipse transformed by the supplied transforms applied in the reverse order.
-func (ec *EllipseColor) Draw(t ...Transform) {
- mat := mgl32.Ident3()
- for i := range t {
- mat = mat.Mul3(t[i].Mat3())
- }
- mat = mat.Mul3(mgl32.Scale2D(float32(ec.radius.X()), float32(ec.radius.Y())))
-
- ec.parent.Do(func(ctx pixelgl.Context) {
- r, g, b, a := colorToRGBA(ec.color)
- ctx.Shader().SetUniformVec4(pixelgl.MaskColor, mgl32.Vec4{r, g, b, a})
- ctx.Shader().SetUniformMat3(pixelgl.Transform, mat)
- })
-
- ec.va.Draw()
-}
-
-// Delete destroys an ellipse shape and releases it's video memory. Do not use this shape after calling Delete.
-func (ec *EllipseColor) Delete() {
- ec.va.Delete()
+// Fill returns the fill ratio of an ellipse.
+func (ec *EllipseColor) Fill() float64 {
+ return ec.fill
}
--
GitLab