replace Transform by much simpler Matrix

batch.go

@@ -3,9 +3,8 @@ package pixel
 import (
 	"fmt"
 	"image/color"
-	"math"
 
-	"github.com/go-gl/mathgl/mgl32"
+	"github.com/go-gl/mathgl/mgl64"
 )
 
 // Batch is a Target that allows for efficient drawing of many objects with the same Picture (but
@@ -16,7 +15,7 @@ import (
 type Batch struct {
 	cont Drawer
 
-	mat mgl32.Mat3
+	mat Matrix
 	col NRGBA
 }
 
@@ -45,9 +44,9 @@ func (b *Batch) Draw(t Target) {
 	b.cont.Draw(t)
 }
 
-// SetTransform sets transforms used in the following draws onto the Batch.
+// SetMatrix sets a Matrix that every point will be projected by.
-func (b *Batch) SetTransform(t ...Transform) {
+func (b *Batch) SetMatrix(m Matrix) {
-	b.mat = transformToMat(t...)
+	b.mat = m
 }
 
 // SetColorMask sets a mask color used in the following draws onto the Batch.
@@ -74,10 +73,12 @@ func (b *Batch) MakeTriangles(t Triangles) TargetTriangles {
 
 // MakePicture returns a specialized copy of the provided Picture that draws onto this Batch.
 func (b *Batch) MakePicture(p Picture) TargetPicture {
-	return &batchPicture{
+	bp := &batchPicture{
 		Picture: p,
 		b:       b,
 	}
+	bp.original = bp
+	return bp
 }
 
 type batchTriangles struct {
@@ -89,15 +90,17 @@ type batchTriangles struct {
 
 func (bt *batchTriangles) draw(bp *batchPicture) {
 	for i := range *bt.trans {
-		transPos := bt.b.mat.Mul3x1(mgl32.Vec3{
+		transPos := mgl64.Mat3(bt.b.mat).Mul3x1(mgl64.Vec3{
-			float32((*bt.orig)[i].Position.X()),
+			(*bt.orig)[i].Position.X(),
-			float32((*bt.orig)[i].Position.Y()),
+			(*bt.orig)[i].Position.Y(),
 			1,
 		})
 		(*bt.trans)[i].Position = V(float64(transPos.X()), float64(transPos.Y()))
 		(*bt.trans)[i].Color = (*bt.orig)[i].Color.Mul(bt.b.col)
+		(*bt.trans)[i].Picture = (*bt.orig)[i].Picture
+		(*bt.trans)[i].Intensity = (*bt.orig)[i].Intensity
 		if bp == nil {
-			(*bt.trans)[i].Picture = V(math.Inf(+1), math.Inf(+1))
+			(*bt.trans)[i].Intensity = 0
 		}
 	}
 
@@ -116,15 +119,21 @@ func (bt *batchTriangles) Draw() {
 type batchPicture struct {
 	Picture
 
+	original *batchPicture
 	b        *Batch
 }
 
 func (bp *batchPicture) Slice(r Rect) Picture {
 	return &batchPicture{
 		Picture:  bp.Picture.Slice(r),
+		original: bp.original,
 	}
 }
 
+func (bp *batchPicture) Original() Picture {
+	return bp.original
+}
+
 func (bp *batchPicture) Draw(t TargetTriangles) {
 	bt := t.(*batchTriangles)
 	if bp.b != bt.b {

geometry.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"math"
 	"math/cmplx"
+
+	"github.com/go-gl/mathgl/mgl64"
 )
 
 // Vec is a 2D vector type. It is unusually implemented as complex128 for convenience. Since
@@ -175,3 +177,63 @@ func (r Rect) Contains(u Vec) bool {
 	min, max := r.Pos, r.Pos+r.Size
 	return min.X() <= u.X() && u.X() <= max.X() && min.Y() <= u.Y() && u.Y() <= max.Y()
 }
+
+// Matrix is a 3x3 transformation matrix that can be used for all kinds of spacial transforms, such
+// as movement, scaling and rotations.
+//
+// Matrix has a handful of useful methods, each of which adds a transformation to the matrix. For
+// example:
+//
+//   pixel.ZM.Move(pixel.V(100, 200)).Rotate(0, math.Pi/2)
+//
+// This code creates a Matrix that first moves everything by 100 units horizontaly and 200 units
+// vertically and then rotates everything by 90 degrees around the origin.
+type Matrix [9]float64
+
+// ZM stands for Zero-Matrix which is the identity matrix. Does nothing, no transformation.
+var ZM = Matrix(mgl64.Ident3())
+
+// Move moves everything by the delta vector.
+func (m Matrix) Move(delta Vec) Matrix {
+	m3 := mgl64.Mat3(m)
+	m3 = mgl64.Translate2D(delta.XY()).Mul3(m3)
+	return Matrix(m3)
+}
+
+// ScaleXY scales everything around a given point by the scale factor in each axis respectively.
+func (m Matrix) ScaleXY(around Vec, scale Vec) Matrix {
+	m3 := mgl64.Mat3(m)
+	m3 = mgl64.Translate2D((-around).XY()).Mul3(m3)
+	m3 = mgl64.Scale2D(scale.XY()).Mul3(m3)
+	m3 = mgl64.Translate2D(around.XY()).Mul3(m3)
+	return Matrix(m3)
+}
+
+// Scale scales everything around a given point by the scale factor.
+func (m Matrix) Scale(around Vec, scale float64) Matrix {
+	return m.ScaleXY(around, V(scale, scale))
+}
+
+// Rotate rotates everything around a given point by the given angle in radians.
+func (m Matrix) Rotate(around Vec, angle float64) Matrix {
+	m3 := mgl64.Mat3(m)
+	m3 = mgl64.Translate2D((-around).XY()).Mul3(m3)
+	m3 = mgl64.Rotate3DZ(angle).Mul3(m3)
+	m3 = mgl64.Translate2D(around.XY()).Mul3(m3)
+	return Matrix(m3)
+}
+
+// Project applies all transformations added to the Matrix to a vector u and returns the result.
+func (m Matrix) Project(u Vec) Vec {
+	m3 := mgl64.Mat3(m)
+	proj := m3.Mul3x1(mgl64.Vec3{u.X(), u.Y(), 1})
+	return V(proj.X(), proj.Y())
+}
+
+// Unproject does the inverse operation to Project.
+func (m Matrix) Unproject(u Vec) Vec {
+	m3 := mgl64.Mat3(m)
+	inv := m3.Inv()
+	unproj := inv.Mul3x1(mgl64.Vec3{u.X(), u.Y(), 1})
+	return V(unproj.X(), unproj.Y())
+}

interface.go

@@ -29,11 +29,10 @@ type Target interface {
 type BasicTarget interface {
 	Target
 
-	// SetTransform sets a Transform that transforms the TrianglesPosition property of all
+	// SetMatrix sets a Matrix that every point will be projected by.
-	// Triangles.
+	SetMatrix(Matrix)
-	SetTransform(...Transform)
 
-	// SetMColorMask sets a color that will be multiplied with the TrianglesColor property of all
+	// SetColorMask sets a color that will be multiplied with the TrianglesColor property of all
 	// Triangles.
 	SetColorMask(color.Color)
 }

pixelgl/canvas.go

@@ -116,9 +116,11 @@ func (c *Canvas) MakePicture(p pixel.Picture) pixel.TargetPicture {
 	return cp
 }
 
-// SetTransform sets a set of Transforms that every position in triangles will be put through.
+// SetMatrix sets a Matrix that every point will be projected by.
-func (c *Canvas) SetTransform(t ...pixel.Transform) {
+func (c *Canvas) SetMatrix(m pixel.Matrix) {
-	c.mat = transformToMat(t...)
+	for i := range m {
+		c.mat[i] = float32(m[i])
+	}
 }
 
 // SetColorMask sets a color that every color in triangles or a picture will be multiplied by.

pixelgl/util.go

@@ -4,17 +4,8 @@ import (
 	"math"
 
 	"github.com/faiface/pixel"
-	"github.com/go-gl/mathgl/mgl32"
 )
 
-func transformToMat(t ...pixel.Transform) mgl32.Mat3 {
-	mat := mgl32.Ident3()
-	for i := range t {
-		mat = mat.Mul3(t[i].Mat())
-	}
-	return mat
-}
-
 func discreteBounds(bounds pixel.Rect) (x, y, w, h int) {
 	x0 := int(math.Floor(bounds.Pos.X()))
 	y0 := int(math.Floor(bounds.Pos.Y()))

pixelgl/window.go

@@ -377,11 +377,9 @@ func (w *Window) MakePicture(p pixel.Picture) pixel.TargetPicture {
 	return w.canvas.MakePicture(p)
 }
 
-// SetTransform sets a global transformation matrix for the Window.
+// SetMatrix sets a Matrix that every point will be projected by.
-//
+func (w *Window) SetMatrix(m pixel.Matrix) {
-// Transforms are applied right-to-left.
+	w.canvas.SetMatrix(m)
-func (w *Window) SetTransform(t ...pixel.Transform) {
-	w.canvas.SetTransform(t...)
 }
 
 // SetColorMask sets a global color mask for the Window.

transform.go

@@ -1,190 +0,0 @@
-package pixel
-
-import "github.com/go-gl/mathgl/mgl32"
-
-// Transform holds space transformation information. Concretely, a transformation is specified
-// by position, anchor, scale and rotation.
-//
-// All points are first rotated around the anchor. Then they are multiplied by the scale. If
-// the scale factor is 2, the object becomes 2x bigger. Finally, all points are moved, so that
-// the original anchor is located precisely at the position.
-//
-// Create a Transform object with Position/Anchor/Rotation/... function. This sets the position
-// one of it's properties. Then use methods, like Scale and Rotate to change scale, rotation and
-// achor. The order in which you apply these methods is irrelevant.
-//
-//   pixel.Position(pixel.V(100, 100)).Rotate(math.Pi / 3).Scale(1.5)
-//
-// Also note, that no method changes the Transform. All simply return a new, changed Transform.
-type Transform struct {
-	pos, anc, sca Vec
-	rot           float64
-}
-
-// ZT stands for Zero-Transform. This Transform is a neutral Transform, does not change anything.
-var ZT = Transform{}.Scale(1)
-
-// Position returns a Zero-Transform with Position set to pos.
-func Position(pos Vec) Transform {
-	return ZT.Position(pos)
-}
-
-// Anchor returns a Zero-Transform with Anchor set to anchor.
-func Anchor(anchor Vec) Transform {
-	return ZT.Anchor(anchor)
-}
-
-// Scale returns a Zero-Transform with Scale set to scale.
-func Scale(scale float64) Transform {
-	return ZT.Scale(scale)
-}
-
-// ScaleXY returns a Zero-Transform with ScaleXY set to scale.
-func ScaleXY(scale Vec) Transform {
-	return ZT.ScaleXY(scale)
-}
-
-// Rotation returns a Zero-Transform with Rotation set to angle (in radians).
-func Rotation(angle float64) Transform {
-	return ZT.Rotation(angle)
-}
-
-// Position moves an object by the specified vector. A zero vector will end up precisely at pos.
-func (t Transform) Position(pos Vec) Transform {
-	t.pos = pos
-	return t
-}
-
-// AddPosition adds delta to the existing Position of this Transform.
-func (t Transform) AddPosition(delta Vec) Transform {
-	t.pos += delta
-	return t
-}
-
-// Anchor specifies the zero vector, point originally located at anchor will be treated as zero.
-// This affects Rotation and Position.
-func (t Transform) Anchor(anchor Vec) Transform {
-	t.anc = anchor
-	return t
-}
-
-// AddAnchor adds delta to the existing Anchor of this Transform.
-func (t Transform) AddAnchor(delta Vec) Transform {
-	t.anc += delta
-	return t
-}
-
-// Scale specifies a factor by which an object will be scaled around it's Anchor.
-//
-// Same as:
-//   t.ScaleXY(pixel.V(scale, scale)).
-func (t Transform) Scale(scale float64) Transform {
-	t.sca = V(scale, scale)
-	return t
-}
-
-// MulScale multiplies the existing Scale of this Transform by factor.
-//
-// Same as:
-//   t.MulScaleXY(pixel.V(factor, factor)).
-func (t Transform) MulScale(factor float64) Transform {
-	t.sca = t.sca.Scaled(factor)
-	return t
-}
-
-// ScaleXY specifies a factor in each dimension, by which an object will be scaled around it's
-// Anchor.
-func (t Transform) ScaleXY(scale Vec) Transform {
-	t.sca = scale
-	return t
-}
-
-// MulScaleXY multiplies the existing ScaleXY of this Transform by factor, component-wise.
-func (t Transform) MulScaleXY(factor Vec) Transform {
-	t.sca = V(
-		t.sca.X()*factor.X(),
-		t.sca.Y()*factor.Y(),
-	)
-	return t
-}
-
-// Rotation specifies an angle by which an object will be rotated around it's Anchor.
-//
-// The angle is in radians.
-func (t Transform) Rotation(angle float64) Transform {
-	t.rot = angle
-	return t
-}
-
-// AddRotation adds delta to the existing Angle of this Transform.
-//
-// The delta is in radians.
-func (t Transform) AddRotation(delta float64) Transform {
-	t.rot += delta
-	return t
-}
-
-// GetPosition returns the Position of the Transform.
-func (t Transform) GetPosition() Vec {
-	return t.pos
-}
-
-// GetAnchor returns the Anchor of the Transform.
-func (t Transform) GetAnchor() Vec {
-	return t.anc
-}
-
-// GetScaleXY returns the ScaleXY of the Transform.
-func (t Transform) GetScaleXY() Vec {
-	return t.sca
-}
-
-// GetRotation returns the Rotation of the Transform.
-func (t Transform) GetRotation() float64 {
-	return t.rot
-}
-
-// Project transforms a vector by a transform.
-func (t Transform) Project(v Vec) Vec {
-	mat := t.Mat()
-	vec := mgl32.Vec3{float32(v.X()), float32(v.Y()), 1}
-	pro := mat.Mul3x1(vec)
-	return V(float64(pro.X()), float64(pro.Y()))
-}
-
-// Unproject does the inverse operation to Project.
-func (t Transform) Unproject(v Vec) Vec {
-	mat := t.InvMat()
-	vec := mgl32.Vec3{float32(v.X()), float32(v.Y()), 1}
-	unp := mat.Mul3x1(vec)
-	return V(float64(unp.X()), float64(unp.Y()))
-}
-
-// Mat returns a transformation matrix that satisfies previously set transform properties.
-func (t Transform) Mat() mgl32.Mat3 {
-	mat := mgl32.Ident3()
-	mat = mat.Mul3(mgl32.Translate2D(float32(t.pos.X()), float32(t.pos.Y())))
-	mat = mat.Mul3(mgl32.Rotate3DZ(float32(t.rot)))
-	mat = mat.Mul3(mgl32.Scale2D(float32(t.sca.X()), float32(t.sca.Y())))
-	mat = mat.Mul3(mgl32.Translate2D(float32(-t.anc.X()), float32(-t.anc.Y())))
-	return mat
-}
-
-// InvMat returns an inverse transformation matrix to the matrix returned by Mat3 method.
-func (t Transform) InvMat() mgl32.Mat3 {
-	mat := mgl32.Ident3()
-	mat = mat.Mul3(mgl32.Translate2D(float32(t.anc.X()), float32(t.anc.Y())))
-	mat = mat.Mul3(mgl32.Scale2D(float32(1/t.sca.X()), float32(1/t.sca.Y())))
-	mat = mat.Mul3(mgl32.Rotate3DZ(float32(-t.rot)))
-	mat = mat.Mul3(mgl32.Translate2D(float32(-t.pos.X()), float32(-t.pos.Y())))
-	return mat
-}
-
-// Camera is a convenience function, that returns a Transform that acts like a camera.	Center is
-// the position in the world coordinates, that will be projected onto the center of the screen.
-// One unit in world coordinates will be projected onto zoom pixels.
-//
-// It is possible to apply additional rotations, scales and moves to the returned transform.
-func Camera(center, zoom, screenSize Vec) Transform {
-	return Anchor(center).ScaleXY(2 * zoom).MulScaleXY(V(1/screenSize.X(), 1/screenSize.Y()))
-}

util.go

@@ -1,7 +1,5 @@
 package pixel
 
-import "github.com/go-gl/mathgl/mgl32"
-
 func clamp(x, low, high float64) float64 {
 	if x < low {
 		return low
@@ -11,11 +9,3 @@ func clamp(x, low, high float64) float64 {
 	}
 	return x
 }
-
-func transformToMat(t ...Transform) mgl32.Mat3 {
-	mat := mgl32.Ident3()
-	for i := range t {
-		mat = mat.Mul3(t[i].Mat())
-	}
-	return mat
-}