add state-of-the-art canvas and use it within window

canvas.go

@@ -0,0 +1,222 @@
+package pixel
+
+import (
+	"image/color"
+
+	"github.com/faiface/mainthread"
+	"github.com/faiface/pixel/pixelgl"
+	"github.com/go-gl/mathgl/mgl32"
+	"github.com/pkg/errors"
+)
+
+// Canvas is basically a Picture that you can draw on.
+//
+// Canvas supports TrianglesPosition, TrianglesColor and TrianglesTexture.
+type Canvas struct {
+	f *pixelgl.Frame
+	s *pixelgl.Shader
+
+	pic *Picture
+	mat mgl32.Mat3
+	col mgl32.Vec4
+	bnd mgl32.Vec4
+}
+
+// NewCanvas creates a new fully transparent Canvas with specified dimensions in pixels.
+func NewCanvas(width, height float64, smooth bool) *Canvas {
+	c := &Canvas{}
+	mainthread.Call(func() {
+		var err error
+		c.f = pixelgl.NewFrame(int(width), int(height), smooth)
+		c.s, err = pixelgl.NewShader(
+			canvasVertexFormat,
+			canvasUniformFormat,
+			canvasVertexShader,
+			canvasFragmentShader,
+		)
+		if err != nil {
+			panic(errors.Wrap(err, "failed to create canvas"))
+		}
+	})
+	c.pic = nil
+	c.mat = mgl32.Ident3()
+	c.col = mgl32.Vec4{1, 1, 1, 1}
+	c.bnd = mgl32.Vec4{0, 0, 1, 1}
+	return c
+}
+
+// Size returns the width and the height of the Canvas in pixels.
+func (c *Canvas) Size() (width, height float64) {
+	return float64(c.f.Width()), float64(c.f.Height())
+}
+
+// Content returns a Picture that contains the content of this Canvas. The returned Picture changes
+// as you draw onto the Canvas, so there is no real need to call this method more than once.
+func (c *Canvas) Content() *Picture {
+	tex := c.f.Texture()
+	return &Picture{
+		texture: tex,
+		bounds:  R(0, 0, float64(tex.Width()), float64(tex.Height())),
+	}
+}
+
+// Clear fill the whole Canvas with on specified color.
+func (c *Canvas) Clear(col color.Color) {
+	mainthread.CallNonBlock(func() {
+		c.f.Begin()
+		col := NRGBAModel.Convert(col).(NRGBA)
+		pixelgl.Clear(float32(col.R), float32(col.G), float32(col.B), float32(col.A))
+		c.f.End()
+	})
+}
+
+// MakeTriangles returns Triangles that draw onto this Canvas.
+func (c *Canvas) MakeTriangles(t Triangles) Triangles {
+	tpcs := NewGLTriangles(c.s, t).(trianglesPositionColorTexture)
+	return &canvasTriangles{
+		c: c,
+		trianglesPositionColorTexture: tpcs,
+	}
+}
+
+// SetPicture sets a Picture that will be used in further draw operations.
+//
+// This does not set the Picture that this Canvas draws onto, don't confuse it.
+func (c *Canvas) SetPicture(p *Picture) {
+	if p != nil {
+		min := pictureBounds(p, V(0, 0))
+		max := pictureBounds(p, V(1, 1))
+		c.bnd = mgl32.Vec4{
+			float32(min.X()), float32(min.Y()),
+			float32(max.X()), float32(max.Y()),
+		}
+	}
+	c.pic = p
+}
+
+// SetTransform sets the transformations used in further draw operations.
+func (c *Canvas) SetTransform(t ...Transform) {
+	c.mat = transformToMat(t...)
+}
+
+// SetMaskColor sets the mask color used in further draw operations.
+func (c *Canvas) SetMaskColor(col color.Color) {
+	if col == nil {
+		col = NRGBA{1, 1, 1, 1}
+	}
+	nrgba := NRGBAModel.Convert(col).(NRGBA)
+	r := float32(nrgba.R)
+	g := float32(nrgba.G)
+	b := float32(nrgba.B)
+	a := float32(nrgba.A)
+	c.col = mgl32.Vec4{r, g, b, a}
+}
+
+type trianglesPositionColorTexture interface {
+	Triangles
+	Position(i int) Vec
+	Color(i int) NRGBA
+	Texture(i int) Vec
+}
+
+type canvasTriangles struct {
+	c *Canvas
+	trianglesPositionColorTexture
+}
+
+func (ct *canvasTriangles) Draw() {
+	// avoid possible race condition
+	pic := ct.c.pic
+	mat := ct.c.mat
+	col := ct.c.col
+	bnd := ct.c.bnd
+
+	mainthread.CallNonBlock(func() {
+		ct.c.f.Begin()
+		ct.c.s.Begin()
+
+		ct.c.s.SetUniformAttr(canvasTransformMat3, mat)
+		ct.c.s.SetUniformAttr(canvasMaskColorVec4, col)
+		ct.c.s.SetUniformAttr(canvasBoundsVec4, bnd)
+
+		if pic != nil {
+			pic.Texture().Begin()
+			ct.trianglesPositionColorTexture.Draw()
+			pic.Texture().End()
+		} else {
+			ct.trianglesPositionColorTexture.Draw()
+		}
+
+		ct.c.s.End()
+		ct.c.f.End()
+	})
+}
+
+const (
+	canvasPositionVec2 int = iota
+	canvasColorVec4
+	canvasTextureVec2
+)
+
+var canvasVertexFormat = pixelgl.AttrFormat{
+	canvasPositionVec2: {Name: "position", Type: pixelgl.Vec2},
+	canvasColorVec4:    {Name: "color", Type: pixelgl.Vec4},
+	canvasTextureVec2:  {Name: "texture", Type: pixelgl.Vec2},
+}
+
+const (
+	canvasMaskColorVec4 int = iota
+	canvasTransformMat3
+	canvasBoundsVec4
+)
+
+var canvasUniformFormat = pixelgl.AttrFormat{
+	{Name: "maskColor", Type: pixelgl.Vec4},
+	{Name: "transform", Type: pixelgl.Mat3},
+	{Name: "bounds", Type: pixelgl.Vec4},
+}
+
+var canvasVertexShader = `
+#version 330 core
+
+in vec2 position;
+in vec4 color;
+in vec2 texture;
+
+out vec4 Color;
+out vec2 Texture;
+
+uniform mat3 transform;
+
+void main() {
+	gl_Position = vec4((transform * vec3(position.x, position.y, 1.0)).xy, 0.0, 1.0);
+	Color = color;
+	Texture = texture;
+}
+`
+
+var canvasFragmentShader = `
+#version 330 core
+
+in vec4 Color;
+in vec2 Texture;
+
+out vec4 color;
+
+uniform vec4 maskColor;
+uniform vec4 bounds;
+uniform sampler2D tex;
+
+void main() {
+	vec2 boundsMin = bounds.xy;
+	vec2 boundsMax = bounds.zw;
+
+	if (Texture == vec2(-1, -1)) {
+		color = maskColor * Color;
+	} else {
+		float tx = boundsMin.x * (1 - Texture.x) + boundsMax.x * Texture.x;
+		float ty = boundsMin.y * (1 - Texture.y) + boundsMax.y * Texture.y;
+		color = maskColor * Color * texture(tex, vec2(tx, ty));
+	}
+}
+`

window.go

@@ -8,7 +8,6 @@ import (
 	"github.com/faiface/mainthread"
 	"github.com/faiface/pixel/pixelgl"
 	"github.com/go-gl/glfw/v3.2/glfw"
-	"github.com/go-gl/mathgl/mgl32"
 	"github.com/pkg/errors"
 )
 
@@ -60,16 +59,10 @@ type Window struct {
 	enabled bool
 	window  *glfw.Window
 	config  WindowConfig
-	shader  *pixelgl.Shader
 
-	// cache
+	canvas   *Canvas
-	width, height float64
+	canvasVs *pixelgl.VertexSlice
-
+	shader   *pixelgl.Shader
-	// Target stuff, Picture, transformation matrix and color
-	pic *Picture
-	mat mgl32.Mat3
-	col mgl32.Vec4
-	bnd mgl32.Vec4
 
 	// need to save these to correctly restore a fullscreen window
 	restore struct {
@@ -80,9 +73,6 @@ type Window struct {
 		buttons [KeyLast + 1]bool
 		scroll  Vec
 	}
-
-	//DEBUG
-	Frame *pixelgl.Frame
 }
 
 var currentWindow *Window
@@ -120,42 +110,52 @@ func NewWindow(config WindowConfig) (*Window, error) {
 		if currentWindow != nil {
 			share = currentWindow.window
 		}
-		w.window, err = glfw.CreateWindow(int(config.Width), int(config.Height), config.Title, nil, share)
+		w.window, err = glfw.CreateWindow(
+			int(config.Width),
+			int(config.Height),
+			config.Title,
+			nil,
+			share,
+		)
 		if err != nil {
 			return err
 		}
 
+		// enter the OpenGL context
+		w.begin()
+		w.end()
+
+		w.shader, err = pixelgl.NewShader(
+			windowVertexFormat,
+			windowUniformFormat,
+			windowVertexShader,
+			windowFragmentShader,
+		)
+		if err != nil {
+			return err
+		}
+
+		w.canvasVs = pixelgl.MakeVertexSlice(w.shader, 6, 6)
+		w.canvasVs.Begin()
+		w.canvasVs.SetVertexData([]float32{
+			-1, -1, 0, 0,
+			1, -1, 1, 0,
+			1, 1, 1, 1,
+			-1, -1, 0, 0,
+			1, 1, 1, 1,
+			-1, 1, 0, 1,
+		})
+		w.canvasVs.End()
+
 		return nil
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "creating window failed")
 	}
 
-	mainthread.Call(func() {
-		w.begin()
-		w.end()
-
-		w.shader, err = pixelgl.NewShader(
-			defaultVertexFormat,
-			defaultUniformFormat,
-			defaultVertexShader,
-			defaultFragmentShader,
-		)
-		if err != nil {
-			panic(errors.Wrap(err, "NewWindow: failed to create shader"))
-		}
-	})
-	if err != nil {
-		w.Destroy()
-		return nil, errors.Wrap(err, "creating window failed")
-	}
-
 	w.initInput()
 	w.SetFullscreen(config.Fullscreen)
-
+	w.Update()
-	w.SetPicture(nil)
-	w.SetTransform()
-	w.SetMaskColor(NRGBA{1, 1, 1, 1})
 
 	runtime.SetFinalizer(w, (*Window).Destroy)
 
@@ -171,18 +171,41 @@ func (w *Window) Destroy() {
 
 // Clear clears the window with a color.
 func (w *Window) Clear(c color.Color) {
-	mainthread.CallNonBlock(func() {
+	w.canvas.Clear(c)
-		w.begin()
-		c := NRGBAModel.Convert(c).(NRGBA)
-		pixelgl.Clear(float32(c.R), float32(c.G), float32(c.B), float32(c.A))
-		w.end()
-	})
 }
 
 // Update swaps buffers and polls events.
 func (w *Window) Update() {
+	width, height := w.Size()
+	if w.canvas == nil || V(w.canvas.Size()) != V(width, height) {
+		oldCanvas := w.canvas
+		w.canvas = NewCanvas(width, height, false)
+		if oldCanvas != nil {
+			td := TrianglesDrawer{Triangles: &TrianglesData{
+				{Position: V(-1, -1), Color: NRGBA{1, 1, 1, 1}, Texture: V(0, 0)},
+				{Position: V(1, -1), Color: NRGBA{1, 1, 1, 1}, Texture: V(1, 0)},
+				{Position: V(1, 1), Color: NRGBA{1, 1, 1, 1}, Texture: V(1, 1)},
+				{Position: V(-1, -1), Color: NRGBA{1, 1, 1, 1}, Texture: V(0, 0)},
+				{Position: V(1, 1), Color: NRGBA{1, 1, 1, 1}, Texture: V(1, 1)},
+				{Position: V(-1, 1), Color: NRGBA{1, 1, 1, 1}, Texture: V(0, 1)},
+			}}
+			w.canvas.SetPicture(oldCanvas.Content())
+			td.Draw(w.canvas)
+		}
+	}
+
 	mainthread.Call(func() {
 		w.begin()
+
+		pixelgl.Clear(0, 0, 0, 0)
+		w.shader.Begin()
+		w.canvas.f.Texture().Begin()
+		w.canvasVs.Begin()
+		w.canvasVs.Draw()
+		w.canvasVs.End()
+		w.canvas.f.Texture().End()
+		w.shader.End()
+
 		if w.config.VSync {
 			glfw.SwapInterval(1)
 		}
@@ -191,8 +214,6 @@ func (w *Window) Update() {
 	})
 
 	w.updateInput()
-
-	w.width, w.height = w.Size()
 }
 
 // SetClosed sets the closed flag of a window.
@@ -346,63 +367,11 @@ func (w *Window) begin() {
 		pixelgl.Init()
 		currentWindow = w
 	}
-	if w.shader != nil {
-		w.shader.Begin()
-	}
-	if w.Frame != nil {
-		w.Frame.Begin()
-		pixelgl.Viewport(0, 0, int32(w.Frame.Width()), int32(w.Frame.Height()))
-	} else {
-		pixelgl.Viewport(0, 0, int32(w.width), int32(w.height))
-	}
 }
 
 // Note: must be called inside the main thread.
 func (w *Window) end() {
-	if w.Frame != nil {
+	// nothing really
-		w.Frame.End()
-	}
-	if w.shader != nil {
-		w.shader.End()
-	}
-}
-
-type trianglesPositionColorTexture interface {
-	Triangles
-	Position(i int) Vec
-	Color(i int) NRGBA
-	Texture(i int) Vec
-}
-
-type windowTriangles struct {
-	w *Window
-	trianglesPositionColorTexture
-}
-
-func (wt *windowTriangles) Draw() {
-	// avoid possible race condition
-	pic := wt.w.pic
-	mat := wt.w.mat
-	col := wt.w.col
-	bnd := wt.w.bnd
-
-	mainthread.CallNonBlock(func() {
-		wt.w.begin()
-
-		wt.w.shader.SetUniformAttr(transformMat3, mat)
-		wt.w.shader.SetUniformAttr(maskColorVec4, col)
-		wt.w.shader.SetUniformAttr(boundsVec4, bnd)
-
-		if pic != nil {
-			pic.Texture().Begin()
-		}
-		wt.trianglesPositionColorTexture.Draw()
-		if pic != nil {
-			pic.Texture().End()
-		}
-
-		wt.w.end()
-	})
 }
 
 // MakeTriangles generates a specialized copy of the supplied triangles that will draw onto this
@@ -410,112 +379,62 @@ func (wt *windowTriangles) Draw() {
 //
 // Window supports TrianglesPosition, TrianglesColor and TrianglesTexture.
 func (w *Window) MakeTriangles(t Triangles) Triangles {
-	tpcs := NewGLTriangles(w.shader, t).(trianglesPositionColorTexture)
+	return w.canvas.MakeTriangles(t)
-	wt := &windowTriangles{
-		w: w,
-		trianglesPositionColorTexture: tpcs,
-	}
-	return wt
 }
 
 // SetPicture sets a Picture that will be used in subsequent drawings onto the window.
 func (w *Window) SetPicture(p *Picture) {
-	if p != nil {
+	w.canvas.SetPicture(p)
-		min := pictureBounds(p, V(0, 0))
-		max := pictureBounds(p, V(1, 1))
-		w.bnd = mgl32.Vec4{
-			float32(min.X()), float32(min.Y()),
-			float32(max.X()), float32(max.Y()),
-		}
-	}
-	w.pic = p
 }
 
 // SetTransform sets a global transformation matrix for the Window.
 //
 // Transforms are applied right-to-left.
 func (w *Window) SetTransform(t ...Transform) {
-	w.mat = transformToMat(t...)
+	w.canvas.SetTransform(t...)
 }
 
 // SetMaskColor sets a global mask color for the Window.
 func (w *Window) SetMaskColor(c color.Color) {
-	if c == nil {
+	w.canvas.SetMaskColor(c)
-		c = NRGBA{1, 1, 1, 1}
-	}
-	nrgba := NRGBAModel.Convert(c).(NRGBA)
-	r := float32(nrgba.R)
-	g := float32(nrgba.G)
-	b := float32(nrgba.B)
-	a := float32(nrgba.A)
-	w.col = mgl32.Vec4{r, g, b, a}
 }
 
 const (
-	positionVec2 int = iota
+	windowPositionVec2 = iota
-	colorVec4
+	windowTextureVec2
-	textureVec2
 )
 
-var defaultVertexFormat = pixelgl.AttrFormat{
+var windowVertexFormat = pixelgl.AttrFormat{
-	positionVec2: {Name: "position", Type: pixelgl.Vec2},
+	windowPositionVec2: {Name: "position", Type: pixelgl.Vec2},
-	colorVec4:    {Name: "color", Type: pixelgl.Vec4},
+	windowTextureVec2:  {Name: "texture", Type: pixelgl.Vec2},
-	textureVec2:  {Name: "texture", Type: pixelgl.Vec2},
 }
 
-const (
+var windowUniformFormat = pixelgl.AttrFormat{}
-	maskColorVec4 int = iota
-	transformMat3
-	boundsVec4
-)
 
-var defaultUniformFormat = pixelgl.AttrFormat{
+var windowVertexShader = `
-	{Name: "maskColor", Type: pixelgl.Vec4},
-	{Name: "transform", Type: pixelgl.Mat3},
-	{Name: "bounds", Type: pixelgl.Vec4},
-}
-
-var defaultVertexShader = `
 #version 330 core
 
 in vec2 position;
-in vec4 color;
 in vec2 texture;
 
-out vec4 Color;
 out vec2 Texture;
 
-uniform mat3 transform;
-
 void main() {
-	gl_Position = vec4((transform * vec3(position.x, position.y, 1.0)).xy, 0.0, 1.0);
+	gl_Position = vec4(position, 0.0, 1.0);
-	Color = color;
 	Texture = texture;
 }
 `
 
-var defaultFragmentShader = `
+var windowFragmentShader = `
 #version 330 core
 
-in vec4 Color;
 in vec2 Texture;
 
 out vec4 color;
 
-uniform vec4 maskColor;
-uniform vec4 bounds;
 uniform sampler2D tex;
 
 void main() {
-	vec2 boundsMin = bounds.xy;
+	color = texture(tex, Texture);
-	vec2 boundsMax = bounds.zw;
-
-	if (Texture == vec2(-1, -1)) {
-		color = maskColor * Color;
-	} else {
-		float tx = boundsMin.x * (1 - Texture.x) + boundsMax.x * Texture.x;
-		float ty = boundsMin.y * (1 - Texture.y) + boundsMax.y * Texture.y;
-		color = maskColor * Color * texture(tex, vec2(tx, 1 - ty));
-	}
 }
 `